1 .. _Implementation_of_Ada_2012_Features:
3 ***********************************
4 Implementation of Ada 2012 Features
5 ***********************************
7 .. index:: Ada 2012 implementation status
9 .. index:: -gnat12 option (gcc)
11 .. index:: pragma Ada_2012
13 .. index:: configuration pragma Ada_2012
15 .. index:: Ada_2012 configuration pragma
17 This chapter contains a complete list of Ada 2012 features that have been
18 implemented as of GNAT version 6.4. Generally, these features are only
19 available if the *-gnat12* (Ada 2012 features enabled) flag is set
20 or if the configuration pragma `Ada_2012` is used.
22 However, new pragmas, attributes, and restrictions are
23 unconditionally available, since the Ada 95 standard allows the addition of
24 new pragmas, attributes, and restrictions (there are exceptions, which are
25 documented in the individual descriptions), and also certain packages
26 were made available in earlier versions of Ada.
28 An ISO date (YYYY-MM-DD) appears in parentheses on the description line.
29 This date shows the implementation date of the feature. Any wavefront
30 subsequent to this date will contain the indicated feature, as will any
31 subsequent releases. A date of 0000-00-00 means that GNAT has always
32 implemented the feature, or implemented it as soon as it appeared as a
33 binding interpretation.
35 Each feature corresponds to an Ada Issue ('AI') approved by the Ada
36 standardization group (ISO/IEC JTC1/SC22/WG9) for inclusion in Ada 2012.
37 The features are ordered based on the relevant sections of the Ada
38 Reference Manual ("RM"). When a given AI relates to multiple points
39 in the RM, the earliest is used.
41 A complete description of the AIs may be found in
42 http://www.ada-auth.org/ai05-summary.html.
44 .. index:: AI-0176 (Ada 2012 feature)
46 * *AI-0176 Quantified expressions (2010-09-29)*
48 Both universally and existentially quantified expressions are implemented.
49 They use the new syntax for iterators proposed in AI05-139-2, as well as
50 the standard Ada loop syntax.
52 RM References: 1.01.04 (12) 2.09 (2/2) 4.04 (7) 4.05.09 (0)
54 .. index:: AI-0079 (Ada 2012 feature)
56 * *AI-0079 Allow other_format characters in source (2010-07-10)*
58 Wide characters in the unicode category *other_format* are now allowed in
59 source programs between tokens, but not within a token such as an identifier.
61 RM References: 2.01 (4/2) 2.02 (7)
63 .. index:: AI-0091 (Ada 2012 feature)
65 * *AI-0091 Do not allow other_format in identifiers (0000-00-00)*
67 Wide characters in the unicode category *other_format* are not permitted
68 within an identifier, since this can be a security problem. The error
69 message for this case has been improved to be more specific, but GNAT has
70 never allowed such characters to appear in identifiers.
72 RM References: 2.03 (3.1/2) 2.03 (4/2) 2.03 (5/2) 2.03 (5.1/2) 2.03 (5.2/2) 2.03 (5.3/2) 2.09 (2/2)
74 .. index:: AI-0100 (Ada 2012 feature)
76 * *AI-0100 Placement of pragmas (2010-07-01)*
78 This AI is an earlier version of AI-163. It simplifies the rules
79 for legal placement of pragmas. In the case of lists that allow pragmas, if
80 the list may have no elements, then the list may consist solely of pragmas.
82 RM References: 2.08 (7)
84 .. index:: AI-0163 (Ada 2012 feature)
86 * *AI-0163 Pragmas in place of null (2010-07-01)*
88 A statement sequence may be composed entirely of pragmas. It is no longer
89 necessary to add a dummy `null` statement to make the sequence legal.
91 RM References: 2.08 (7) 2.08 (16)
93 .. index:: AI-0080 (Ada 2012 feature)
95 * *AI-0080 'View of' not needed if clear from context (0000-00-00)*
97 This is an editorial change only, described as non-testable in the AI.
99 RM References: 3.01 (7)
101 .. index:: AI-0183 (Ada 2012 feature)
103 * *AI-0183 Aspect specifications (2010-08-16)*
105 Aspect specifications have been fully implemented except for pre and post-
106 conditions, and type invariants, which have their own separate AI's. All
107 forms of declarations listed in the AI are supported. The following is a
108 list of the aspects supported (with GNAT implementation aspects marked)
110 ================================== ===========
111 Supported Aspect Source
112 ================================== ===========
121 `Contract_Cases` -- GNAT
124 `Favor_Top_Level` -- GNAT
126 `Inline_Always` -- GNAT
130 `Object_Size` -- GNAT
132 `Persistent_BSS` -- GNAT
136 `Preelaborable_Initialization`
137 `Pure_Function` -- GNAT
138 `Remote_Access_Type` -- GNAT
145 `Suppress_Debug_Info` -- GNAT
147 `Thread_Local_Storage` -- GNAT
150 `Universal_Aliasing` -- GNAT
152 `Unreferenced` -- GNAT
153 `Unreferenced_Objects` -- GNAT
157 `Volatile_Components`
159 ================================== ===========
161 Note that for aspects with an expression, e.g. `Size`, the expression is
162 treated like a default expression (visibility is analyzed at the point of
163 occurrence of the aspect, but evaluation of the expression occurs at the
164 freeze point of the entity involved).
166 RM References: 3.02.01 (3) 3.02.02 (2) 3.03.01 (2/2) 3.08 (6)
167 3.09.03 (1.1/2) 6.01 (2/2) 6.07 (2/2) 9.05.02 (2/2) 7.01 (3) 7.03
168 (2) 7.03 (3) 9.01 (2/2) 9.01 (3/2) 9.04 (2/2) 9.04 (3/2)
169 9.05.02 (2/2) 11.01 (2) 12.01 (3) 12.03 (2/2) 12.04 (2/2) 12.05 (2)
170 12.06 (2.1/2) 12.06 (2.2/2) 12.07 (2) 13.01 (0.1/2) 13.03 (5/1)
173 .. index:: AI-0128 (Ada 2012 feature)
175 * *AI-0128 Inequality is a primitive operation (0000-00-00)*
177 If an equality operator ("=") is declared for a type, then the implicitly
178 declared inequality operator ("/=") is a primitive operation of the type.
179 This is the only reasonable interpretation, and is the one always implemented
180 by GNAT, but the RM was not entirely clear in making this point.
182 RM References: 3.02.03 (6) 6.06 (6)
184 .. index:: AI-0003 (Ada 2012 feature)
186 * *AI-0003 Qualified expressions as names (2010-07-11)*
188 In Ada 2012, a qualified expression is considered to be syntactically a name,
189 meaning that constructs such as `A'(F(X)).B` are now legal. This is
190 useful in disambiguating some cases of overloading.
192 RM References: 3.03 (11) 3.03 (21) 4.01 (2) 4.04 (7) 4.07 (3)
195 .. index:: AI-0120 (Ada 2012 feature)
197 * *AI-0120 Constant instance of protected object (0000-00-00)*
199 This is an RM editorial change only. The section that lists objects that are
200 constant failed to include the current instance of a protected object
201 within a protected function. This has always been treated as a constant
204 RM References: 3.03 (21)
206 .. index:: AI-0008 (Ada 2012 feature)
208 * *AI-0008 General access to constrained objects (0000-00-00)*
210 The wording in the RM implied that if you have a general access to a
211 constrained object, it could be used to modify the discriminants. This was
212 obviously not intended. `Constraint_Error` should be raised, and GNAT
213 has always done so in this situation.
215 RM References: 3.03 (23) 3.10.02 (26/2) 4.01 (9) 6.04.01 (17) 8.05.01 (5/2)
217 .. index:: AI-0093 (Ada 2012 feature)
219 * *AI-0093 Additional rules use immutably limited (0000-00-00)*
221 This is an editorial change only, to make more widespread use of the Ada 2012
224 RM References: 3.03 (23.4/3)
226 .. index:: AI-0096 (Ada 2012 feature)
228 * *AI-0096 Deriving from formal private types (2010-07-20)*
230 In general it is illegal for a type derived from a formal limited type to be
231 nonlimited. This AI makes an exception to this rule: derivation is legal
232 if it appears in the private part of the generic, and the formal type is not
233 tagged. If the type is tagged, the legality check must be applied to the
234 private part of the package.
236 RM References: 3.04 (5.1/2) 6.02 (7)
238 .. index:: AI-0181 (Ada 2012 feature)
240 * *AI-0181 Soft hyphen is a non-graphic character (2010-07-23)*
242 From Ada 2005 on, soft hyphen is considered a non-graphic character, which
243 means that it has a special name (`SOFT_HYPHEN`) in conjunction with the
244 `Image` and `Value` attributes for the character types. Strictly
245 speaking this is an inconsistency with Ada 95, but in practice the use of
246 these attributes is so obscure that it will not cause problems.
248 RM References: 3.05.02 (2/2) A.01 (35/2) A.03.03 (21)
250 .. index:: AI-0182 (Ada 2012 feature)
252 * *AI-0182 Additional forms for `Character'Value* (0000-00-00)`
254 This AI allows `Character'Value` to accept the string `'?'` where
255 `?` is any character including non-graphic control characters. GNAT has
256 always accepted such strings. It also allows strings such as
257 `HEX_00000041` to be accepted, but GNAT does not take advantage of this
258 permission and raises `Constraint_Error`, as is certainly still
261 RM References: 3.05 (56/2)
263 .. index:: AI-0214 (Ada 2012 feature)
265 * *AI-0214 Defaulted discriminants for limited tagged (2010-10-01)*
267 Ada 2012 relaxes the restriction that forbids discriminants of tagged types
268 to have default expressions by allowing them when the type is limited. It
269 is often useful to define a default value for a discriminant even though
270 it can't be changed by assignment.
272 RM References: 3.07 (9.1/2) 3.07.02 (3)
274 .. index:: AI-0102 (Ada 2012 feature)
276 * *AI-0102 Some implicit conversions are illegal (0000-00-00)*
278 It is illegal to assign an anonymous access constant to an anonymous access
279 variable. The RM did not have a clear rule to prevent this, but GNAT has
280 always generated an error for this usage.
282 RM References: 3.07 (16) 3.07.01 (9) 6.04.01 (6) 8.06 (27/2)
284 .. index:: AI-0158 (Ada 2012 feature)
286 * *AI-0158 Generalizing membership tests (2010-09-16)*
288 This AI extends the syntax of membership tests to simplify complex conditions
289 that can be expressed as membership in a subset of values of any type. It
290 introduces syntax for a list of expressions that may be used in loop contexts
293 RM References: 3.08.01 (5) 4.04 (3) 4.05.02 (3) 4.05.02 (5) 4.05.02 (27)
295 .. index:: AI-0173 (Ada 2012 feature)
297 * *AI-0173 Testing if tags represent abstract types (2010-07-03)*
299 The function `Ada.Tags.Type_Is_Abstract` returns `True` if invoked
300 with the tag of an abstract type, and `False` otherwise.
302 RM References: 3.09 (7.4/2) 3.09 (12.4/2)
304 .. index:: AI-0076 (Ada 2012 feature)
306 * *AI-0076 function with controlling result (0000-00-00)*
308 This is an editorial change only. The RM defines calls with controlling
309 results, but uses the term 'function with controlling result' without an
312 RM References: 3.09.02 (2/2)
314 .. index:: AI-0126 (Ada 2012 feature)
316 * *AI-0126 Dispatching with no declared operation (0000-00-00)*
318 This AI clarifies dispatching rules, and simply confirms that dispatching
319 executes the operation of the parent type when there is no explicitly or
320 implicitly declared operation for the descendant type. This has always been
321 the case in all versions of GNAT.
323 RM References: 3.09.02 (20/2) 3.09.02 (20.1/2) 3.09.02 (20.2/2)
325 .. index:: AI-0097 (Ada 2012 feature)
327 * *AI-0097 Treatment of abstract null extension (2010-07-19)*
329 The RM as written implied that in some cases it was possible to create an
330 object of an abstract type, by having an abstract extension inherit a non-
331 abstract constructor from its parent type. This mistake has been corrected
332 in GNAT and in the RM, and this construct is now illegal.
334 RM References: 3.09.03 (4/2)
336 .. index:: AI-0203 (Ada 2012 feature)
338 * *AI-0203 Extended return cannot be abstract (0000-00-00)*
340 A return_subtype_indication cannot denote an abstract subtype. GNAT has never
341 permitted such usage.
343 RM References: 3.09.03 (8/3)
345 .. index:: AI-0198 (Ada 2012 feature)
347 * *AI-0198 Inheriting abstract operators (0000-00-00)*
349 This AI resolves a conflict between two rules involving inherited abstract
350 operations and predefined operators. If a derived numeric type inherits
351 an abstract operator, it overrides the predefined one. This interpretation
352 was always the one implemented in GNAT.
354 RM References: 3.09.03 (4/3)
356 .. index:: AI-0073 (Ada 2012 feature)
358 * *AI-0073 Functions returning abstract types (2010-07-10)*
360 This AI covers a number of issues regarding returning abstract types. In
361 particular generic functions cannot have abstract result types or access
362 result types designated an abstract type. There are some other cases which
363 are detailed in the AI. Note that this binding interpretation has not been
364 retrofitted to operate before Ada 2012 mode, since it caused a significant
365 number of regressions.
367 RM References: 3.09.03 (8) 3.09.03 (10) 6.05 (8/2)
369 .. index:: AI-0070 (Ada 2012 feature)
371 * *AI-0070 Elaboration of interface types (0000-00-00)*
373 This is an editorial change only, there are no testable consequences short of
374 checking for the absence of generated code for an interface declaration.
376 RM References: 3.09.04 (18/2)
378 .. index:: AI-0208 (Ada 2012 feature)
380 * *AI-0208 Characteristics of incomplete views (0000-00-00)*
382 The wording in the Ada 2005 RM concerning characteristics of incomplete views
383 was incorrect and implied that some programs intended to be legal were now
384 illegal. GNAT had never considered such programs illegal, so it has always
385 implemented the intent of this AI.
387 RM References: 3.10.01 (2.4/2) 3.10.01 (2.6/2)
389 .. index:: AI-0162 (Ada 2012 feature)
391 * *AI-0162 Incomplete type completed by partial view (2010-09-15)*
393 Incomplete types are made more useful by allowing them to be completed by
394 private types and private extensions.
396 RM References: 3.10.01 (2.5/2) 3.10.01 (2.6/2) 3.10.01 (3) 3.10.01 (4/2)
398 .. index:: AI-0098 (Ada 2012 feature)
400 * *AI-0098 Anonymous subprogram access restrictions (0000-00-00)*
402 An unintentional omission in the RM implied some inconsistent restrictions on
403 the use of anonymous access to subprogram values. These restrictions were not
404 intentional, and have never been enforced by GNAT.
406 RM References: 3.10.01 (6) 3.10.01 (9.2/2)
408 .. index:: AI-0199 (Ada 2012 feature)
410 * *AI-0199 Aggregate with anonymous access components (2010-07-14)*
412 A choice list in a record aggregate can include several components of
413 (distinct) anonymous access types as long as they have matching designated
416 RM References: 4.03.01 (16)
418 .. index:: AI-0220 (Ada 2012 feature)
420 * *AI-0220 Needed components for aggregates (0000-00-00)*
422 This AI addresses a wording problem in the RM that appears to permit some
423 complex cases of aggregates with non-static discriminants. GNAT has always
424 implemented the intended semantics.
426 RM References: 4.03.01 (17)
428 .. index:: AI-0147 (Ada 2012 feature)
430 * *AI-0147 Conditional expressions (2009-03-29)*
432 Conditional expressions are permitted. The form of such an expression is:
436 (if expr then expr {elsif expr then expr} [else expr])
438 The parentheses can be omitted in contexts where parentheses are present
439 anyway, such as subprogram arguments and pragma arguments. If the **else**
440 clause is omitted, **else** *True* is assumed;
441 thus ``(if A then B)`` is a way to conveniently represent
442 *(A implies B)* in standard logic.
444 RM References: 4.03.03 (15) 4.04 (1) 4.04 (7) 4.05.07 (0) 4.07 (2)
445 4.07 (3) 4.09 (12) 4.09 (33) 5.03 (3) 5.03 (4) 7.05 (2.1/2)
447 .. index:: AI-0037 (Ada 2012 feature)
449 * *AI-0037 Out-of-range box associations in aggregate (0000-00-00)*
451 This AI confirms that an association of the form `Indx => <>` in an
452 array aggregate must raise `Constraint_Error` if `Indx`
453 is out of range. The RM specified a range check on other associations, but
454 not when the value of the association was defaulted. GNAT has always inserted
455 a constraint check on the index value.
457 RM References: 4.03.03 (29)
459 .. index:: AI-0123 (Ada 2012 feature)
461 * *AI-0123 Composability of equality (2010-04-13)*
463 Equality of untagged record composes, so that the predefined equality for a
464 composite type that includes a component of some untagged record type
465 `R` uses the equality operation of `R` (which may be user-defined
466 or predefined). This makes the behavior of untagged records identical to that
467 of tagged types in this respect.
469 This change is an incompatibility with previous versions of Ada, but it
470 corrects a non-uniformity that was often a source of confusion. Analysis of
471 a large number of industrial programs indicates that in those rare cases
472 where a composite type had an untagged record component with a user-defined
473 equality, either there was no use of the composite equality, or else the code
474 expected the same composability as for tagged types, and thus had a bug that
475 would be fixed by this change.
477 RM References: 4.05.02 (9.7/2) 4.05.02 (14) 4.05.02 (15) 4.05.02 (24)
480 .. index:: AI-0088 (Ada 2012 feature)
482 * *AI-0088 The value of exponentiation (0000-00-00)*
484 This AI clarifies the equivalence rule given for the dynamic semantics of
485 exponentiation: the value of the operation can be obtained by repeated
486 multiplication, but the operation can be implemented otherwise (for example
487 using the familiar divide-by-two-and-square algorithm, even if this is less
488 accurate), and does not imply repeated reads of a volatile base.
490 RM References: 4.05.06 (11)
492 .. index:: AI-0188 (Ada 2012 feature)
494 * *AI-0188 Case expressions (2010-01-09)*
496 Case expressions are permitted. This allows use of constructs such as:
500 X := (case Y is when 1 => 2, when 2 => 3, when others => 31)
502 RM References: 4.05.07 (0) 4.05.08 (0) 4.09 (12) 4.09 (33)
504 .. index:: AI-0104 (Ada 2012 feature)
506 * *AI-0104 Null exclusion and uninitialized allocator (2010-07-15)*
508 The assignment ``Ptr := new not null Some_Ptr;`` will raise
509 ``Constraint_Error`` because the default value of the allocated object is
510 **null**. This useless construct is illegal in Ada 2012.
512 RM References: 4.08 (2)
514 .. index:: AI-0157 (Ada 2012 feature)
516 * *AI-0157 Allocation/Deallocation from empty pool (2010-07-11)*
518 Allocation and Deallocation from an empty storage pool (i.e. allocation or
519 deallocation of a pointer for which a static storage size clause of zero
520 has been given) is now illegal and is detected as such. GNAT
521 previously gave a warning but not an error.
523 RM References: 4.08 (5.3/2) 13.11.02 (4) 13.11.02 (17)
525 .. index:: AI-0179 (Ada 2012 feature)
527 * *AI-0179 Statement not required after label (2010-04-10)*
529 It is not necessary to have a statement following a label, so a label
530 can appear at the end of a statement sequence without the need for putting a
531 null statement afterwards, but it is not allowable to have only labels and
532 no real statements in a statement sequence.
534 RM References: 5.01 (2)
536 .. index:: AI-0139-2 (Ada 2012 feature)
538 * *AI-0139-2 Syntactic sugar for iterators (2010-09-29)*
540 The new syntax for iterating over arrays and containers is now implemented.
541 Iteration over containers is for now limited to read-only iterators. Only
542 default iterators are supported, with the syntax: `for Elem of C`.
546 .. index:: AI-0134 (Ada 2012 feature)
548 * *AI-0134 Profiles must match for full conformance (0000-00-00)*
550 For full conformance, the profiles of anonymous-access-to-subprogram
551 parameters must match. GNAT has always enforced this rule.
553 RM References: 6.03.01 (18)
555 .. index:: AI-0207 (Ada 2012 feature)
557 * *AI-0207 Mode conformance and access constant (0000-00-00)*
559 This AI confirms that access_to_constant indication must match for mode
560 conformance. This was implemented in GNAT when the qualifier was originally
561 introduced in Ada 2005.
563 RM References: 6.03.01 (16/2)
565 .. index:: AI-0046 (Ada 2012 feature)
567 * *AI-0046 Null exclusion match for full conformance (2010-07-17)*
569 For full conformance, in the case of access parameters, the null exclusion
570 must match (either both or neither must have ``not null``).
572 RM References: 6.03.02 (18)
574 .. index:: AI-0118 (Ada 2012 feature)
576 * *AI-0118 The association of parameter associations (0000-00-00)*
578 This AI clarifies the rules for named associations in subprogram calls and
579 generic instantiations. The rules have been in place since Ada 83.
581 RM References: 6.04.01 (2) 12.03 (9)
583 .. index:: AI-0196 (Ada 2012 feature)
585 * *AI-0196 Null exclusion tests for out parameters (0000-00-00)*
587 Null exclusion checks are not made for `**out**` parameters when
588 evaluating the actual parameters. GNAT has never generated these checks.
590 RM References: 6.04.01 (13)
592 .. index:: AI-0015 (Ada 2012 feature)
594 * *AI-0015 Constant return objects (0000-00-00)*
596 The return object declared in an *extended_return_statement* may be
597 declared constant. This was always intended, and GNAT has always allowed it.
599 RM References: 6.05 (2.1/2) 3.03 (10/2) 3.03 (21) 6.05 (5/2)
602 .. index:: AI-0032 (Ada 2012 feature)
604 * *AI-0032 Extended return for class-wide functions (0000-00-00)*
606 If a function returns a class-wide type, the object of an extended return
607 statement can be declared with a specific type that is covered by the class-
608 wide type. This has been implemented in GNAT since the introduction of
609 extended returns. Note AI-0103 complements this AI by imposing matching
610 rules for constrained return types.
612 RM References: 6.05 (5.2/2) 6.05 (5.3/2) 6.05 (5.6/2) 6.05 (5.8/2)
615 .. index:: AI-0103 (Ada 2012 feature)
617 * *AI-0103 Static matching for extended return (2010-07-23)*
619 If the return subtype of a function is an elementary type or a constrained
620 type, the subtype indication in an extended return statement must match
621 statically this return subtype.
623 RM References: 6.05 (5.2/2)
625 .. index:: AI-0058 (Ada 2012 feature)
627 * *AI-0058 Abnormal completion of an extended return (0000-00-00)*
629 The RM had some incorrect wording implying wrong treatment of abnormal
630 completion in an extended return. GNAT has always implemented the intended
631 correct semantics as described by this AI.
633 RM References: 6.05 (22/2)
635 .. index:: AI-0050 (Ada 2012 feature)
637 * *AI-0050 Raising Constraint_Error early for function call (0000-00-00)*
639 The implementation permissions for raising `Constraint_Error` early on a function call
640 when it was clear an exception would be raised were over-permissive and allowed
641 mishandling of discriminants in some cases. GNAT did
642 not take advantage of these incorrect permissions in any case.
644 RM References: 6.05 (24/2)
646 .. index:: AI-0125 (Ada 2012 feature)
648 * *AI-0125 Nonoverridable operations of an ancestor (2010-09-28)*
650 In Ada 2012, the declaration of a primitive operation of a type extension
651 or private extension can also override an inherited primitive that is not
652 visible at the point of this declaration.
654 RM References: 7.03.01 (6) 8.03 (23) 8.03.01 (5/2) 8.03.01 (6/2)
656 .. index:: AI-0062 (Ada 2012 feature)
658 * *AI-0062 Null exclusions and deferred constants (0000-00-00)*
660 A full constant may have a null exclusion even if its associated deferred
661 constant does not. GNAT has always allowed this.
663 RM References: 7.04 (6/2) 7.04 (7.1/2)
665 .. index:: AI-0178 (Ada 2012 feature)
667 * *AI-0178 Incomplete views are limited (0000-00-00)*
669 This AI clarifies the role of incomplete views and plugs an omission in the
670 RM. GNAT always correctly restricted the use of incomplete views and types.
672 RM References: 7.05 (3/2) 7.05 (6/2)
674 .. index:: AI-0087 (Ada 2012 feature)
676 * *AI-0087 Actual for formal nonlimited derived type (2010-07-15)*
678 The actual for a formal nonlimited derived type cannot be limited. In
679 particular, a formal derived type that extends a limited interface but which
680 is not explicitly limited cannot be instantiated with a limited type.
682 RM References: 7.05 (5/2) 12.05.01 (5.1/2)
684 .. index:: AI-0099 (Ada 2012 feature)
686 * *AI-0099 Tag determines whether finalization needed (0000-00-00)*
688 This AI clarifies that 'needs finalization' is part of dynamic semantics,
689 and therefore depends on the run-time characteristics of an object (i.e. its
690 tag) and not on its nominal type. As the AI indicates: "we do not expect
691 this to affect any implementation''.
693 RM References: 7.06.01 (6) 7.06.01 (7) 7.06.01 (8) 7.06.01 (9/2)
695 .. index:: AI-0064 (Ada 2012 feature)
697 * *AI-0064 Redundant finalization rule (0000-00-00)*
699 This is an editorial change only. The intended behavior is already checked
700 by an existing ACATS test, which GNAT has always executed correctly.
702 RM References: 7.06.01 (17.1/1)
704 .. index:: AI-0026 (Ada 2012 feature)
706 * *AI-0026 Missing rules for Unchecked_Union (2010-07-07)*
708 Record representation clauses concerning Unchecked_Union types cannot mention
709 the discriminant of the type. The type of a component declared in the variant
710 part of an Unchecked_Union cannot be controlled, have controlled components,
711 nor have protected or task parts. If an Unchecked_Union type is declared
712 within the body of a generic unit or its descendants, then the type of a
713 component declared in the variant part cannot be a formal private type or a
714 formal private extension declared within the same generic unit.
716 RM References: 7.06 (9.4/2) B.03.03 (9/2) B.03.03 (10/2)
718 .. index:: AI-0205 (Ada 2012 feature)
720 * *AI-0205 Extended return declares visible name (0000-00-00)*
722 This AI corrects a simple omission in the RM. Return objects have always
723 been visible within an extended return statement.
725 RM References: 8.03 (17)
727 .. index:: AI-0042 (Ada 2012 feature)
729 * *AI-0042 Overriding versus implemented-by (0000-00-00)*
731 This AI fixes a wording gap in the RM. An operation of a synchronized
732 interface can be implemented by a protected or task entry, but the abstract
733 operation is not being overridden in the usual sense, and it must be stated
734 separately that this implementation is legal. This has always been the case
737 RM References: 9.01 (9.2/2) 9.04 (11.1/2)
739 .. index:: AI-0030 (Ada 2012 feature)
741 * *AI-0030 Requeue on synchronized interfaces (2010-07-19)*
743 Requeue is permitted to a protected, synchronized or task interface primitive
744 providing it is known that the overriding operation is an entry. Otherwise
745 the requeue statement has the same effect as a procedure call. Use of pragma
746 `Implemented` provides a way to impose a static requirement on the
747 overriding operation by adhering to one of the implementation kinds: entry,
748 protected procedure or any of the above.
750 RM References: 9.05 (9) 9.05.04 (2) 9.05.04 (3) 9.05.04 (5)
751 9.05.04 (6) 9.05.04 (7) 9.05.04 (12)
753 .. index:: AI-0201 (Ada 2012 feature)
755 * *AI-0201 Independence of atomic object components (2010-07-22)*
757 If an Atomic object has a pragma `Pack` or a `Component_Size`
758 attribute, then individual components may not be addressable by independent
759 tasks. However, if the representation clause has no effect (is confirming),
760 then independence is not compromised. Furthermore, in GNAT, specification of
761 other appropriately addressable component sizes (e.g. 16 for 8-bit
762 characters) also preserves independence. GNAT now gives very clear warnings
763 both for the declaration of such a type, and for any assignment to its components.
765 RM References: 9.10 (1/3) C.06 (22/2) C.06 (23/2)
767 .. index:: AI-0009 (Ada 2012 feature)
769 * *AI-0009 Pragma Independent[_Components] (2010-07-23)*
771 This AI introduces the new pragmas `Independent` and
772 `Independent_Components`,
773 which control guaranteeing independence of access to objects and components.
774 The AI also requires independence not unaffected by confirming rep clauses.
776 RM References: 9.10 (1) 13.01 (15/1) 13.02 (9) 13.03 (13) C.06 (2)
777 C.06 (4) C.06 (6) C.06 (9) C.06 (13) C.06 (14)
779 .. index:: AI-0072 (Ada 2012 feature)
781 * *AI-0072 Task signalling using 'Terminated (0000-00-00)*
783 This AI clarifies that task signalling for reading `'Terminated` only
784 occurs if the result is True. GNAT semantics has always been consistent with
785 this notion of task signalling.
787 RM References: 9.10 (6.1/1)
789 .. index:: AI-0108 (Ada 2012 feature)
791 * *AI-0108 Limited incomplete view and discriminants (0000-00-00)*
793 This AI confirms that an incomplete type from a limited view does not have
794 discriminants. This has always been the case in GNAT.
796 RM References: 10.01.01 (12.3/2)
798 .. index:: AI-0129 (Ada 2012 feature)
800 * *AI-0129 Limited views and incomplete types (0000-00-00)*
802 This AI clarifies the description of limited views: a limited view of a
803 package includes only one view of a type that has an incomplete declaration
804 and a full declaration (there is no possible ambiguity in a client package).
805 This AI also fixes an omission: a nested package in the private part has no
806 limited view. GNAT always implemented this correctly.
808 RM References: 10.01.01 (12.2/2) 10.01.01 (12.3/2)
810 .. index:: AI-0077 (Ada 2012 feature)
812 * *AI-0077 Limited withs and scope of declarations (0000-00-00)*
814 This AI clarifies that a declaration does not include a context clause,
815 and confirms that it is illegal to have a context in which both a limited
816 and a nonlimited view of a package are accessible. Such double visibility
817 was always rejected by GNAT.
819 RM References: 10.01.02 (12/2) 10.01.02 (21/2) 10.01.02 (22/2)
821 .. index:: AI-0122 (Ada 2012 feature)
823 * *AI-0122 Private with and children of generics (0000-00-00)*
825 This AI clarifies the visibility of private children of generic units within
826 instantiations of a parent. GNAT has always handled this correctly.
828 RM References: 10.01.02 (12/2)
830 .. index:: AI-0040 (Ada 2012 feature)
832 * *AI-0040 Limited with clauses on descendant (0000-00-00)*
834 This AI confirms that a limited with clause in a child unit cannot name
835 an ancestor of the unit. This has always been checked in GNAT.
837 RM References: 10.01.02 (20/2)
839 .. index:: AI-0132 (Ada 2012 feature)
841 * *AI-0132 Placement of library unit pragmas (0000-00-00)*
843 This AI fills a gap in the description of library unit pragmas. The pragma
844 clearly must apply to a library unit, even if it does not carry the name
845 of the enclosing unit. GNAT has always enforced the required check.
847 RM References: 10.01.05 (7)
849 .. index:: AI-0034 (Ada 2012 feature)
851 * *AI-0034 Categorization of limited views (0000-00-00)*
853 The RM makes certain limited with clauses illegal because of categorization
854 considerations, when the corresponding normal with would be legal. This is
855 not intended, and GNAT has always implemented the recommended behavior.
857 RM References: 10.02.01 (11/1) 10.02.01 (17/2)
859 .. index:: AI-0035 (Ada 2012 feature)
861 * *AI-0035 Inconsistencies with Pure units (0000-00-00)*
863 This AI remedies some inconsistencies in the legality rules for Pure units.
864 Derived access types are legal in a pure unit (on the assumption that the
865 rule for a zero storage pool size has been enforced on the ancestor type).
866 The rules are enforced in generic instances and in subunits. GNAT has always
867 implemented the recommended behavior.
869 RM References: 10.02.01 (15.1/2) 10.02.01 (15.4/2) 10.02.01 (15.5/2) 10.02.01 (17/2)
871 .. index:: AI-0219 (Ada 2012 feature)
873 * *AI-0219 Pure permissions and limited parameters (2010-05-25)*
875 This AI refines the rules for the cases with limited parameters which do not
876 allow the implementations to omit 'redundant'. GNAT now properly conforms
877 to the requirements of this binding interpretation.
879 RM References: 10.02.01 (18/2)
881 .. index:: AI-0043 (Ada 2012 feature)
883 * *AI-0043 Rules about raising exceptions (0000-00-00)*
885 This AI covers various omissions in the RM regarding the raising of
886 exceptions. GNAT has always implemented the intended semantics.
888 RM References: 11.04.01 (10.1/2) 11 (2)
890 .. index:: AI-0200 (Ada 2012 feature)
892 * *AI-0200 Mismatches in formal package declarations (0000-00-00)*
894 This AI plugs a gap in the RM which appeared to allow some obviously intended
895 illegal instantiations. GNAT has never allowed these instantiations.
897 RM References: 12.07 (16)
899 .. index:: AI-0112 (Ada 2012 feature)
901 * *AI-0112 Detection of duplicate pragmas (2010-07-24)*
903 This AI concerns giving names to various representation aspects, but the
904 practical effect is simply to make the use of duplicate
905 `Atomic[_Components]`,
906 `Volatile[_Components]`, and
907 `Independent[_Components]` pragmas illegal, and GNAT
908 now performs this required check.
910 RM References: 13.01 (8)
912 .. index:: AI-0106 (Ada 2012 feature)
914 * *AI-0106 No representation pragmas on generic formals (0000-00-00)*
916 The RM appeared to allow representation pragmas on generic formal parameters,
917 but this was not intended, and GNAT has never permitted this usage.
919 RM References: 13.01 (9.1/1)
921 .. index:: AI-0012 (Ada 2012 feature)
923 * *AI-0012 Pack/Component_Size for aliased/atomic (2010-07-15)*
925 It is now illegal to give an inappropriate component size or a pragma
926 `Pack` that attempts to change the component size in the case of atomic
927 or aliased components. Previously GNAT ignored such an attempt with a
930 RM References: 13.02 (6.1/2) 13.02 (7) C.06 (10) C.06 (11) C.06 (21)
932 .. index:: AI-0039 (Ada 2012 feature)
934 * *AI-0039 Stream attributes cannot be dynamic (0000-00-00)*
936 The RM permitted the use of dynamic expressions (such as ``ptr.all``)`
937 for stream attributes, but these were never useful and are now illegal. GNAT
938 has always regarded such expressions as illegal.
940 RM References: 13.03 (4) 13.03 (6) 13.13.02 (38/2)
942 .. index:: AI-0095 (Ada 2012 feature)
944 * *AI-0095 Address of intrinsic subprograms (0000-00-00)*
946 The prefix of `'Address` cannot statically denote a subprogram with
947 convention `Intrinsic`. The use of the `Address` attribute raises
948 `Program_Error` if the prefix denotes a subprogram with convention
951 RM References: 13.03 (11/1)
953 .. index:: AI-0116 (Ada 2012 feature)
955 * *AI-0116 Alignment of class-wide objects (0000-00-00)*
957 This AI requires that the alignment of a class-wide object be no greater
958 than the alignment of any type in the class. GNAT has always followed this
961 RM References: 13.03 (29) 13.11 (16)
963 .. index:: AI-0146 (Ada 2012 feature)
965 * *AI-0146 Type invariants (2009-09-21)*
967 Type invariants may be specified for private types using the aspect notation.
968 Aspect `Type_Invariant` may be specified for any private type,
969 `Type_Invariant'Class` can
970 only be specified for tagged types, and is inherited by any descendent of the
971 tagged types. The invariant is a boolean expression that is tested for being
972 true in the following situations: conversions to the private type, object
973 declarations for the private type that are default initialized, and
975 parameters and returned result on return from any primitive operation for
976 the type that is visible to a client.
977 GNAT defines the synonyms `Invariant` for `Type_Invariant` and
978 `Invariant'Class` for `Type_Invariant'Class`.
980 RM References: 13.03.03 (00)
982 .. index:: AI-0078 (Ada 2012 feature)
984 * *AI-0078 Relax Unchecked_Conversion alignment rules (0000-00-00)*
986 In Ada 2012, compilers are required to support unchecked conversion where the
987 target alignment is a multiple of the source alignment. GNAT always supported
988 this case (and indeed all cases of differing alignments, doing copies where
989 required if the alignment was reduced).
991 RM References: 13.09 (7)
993 .. index:: AI-0195 (Ada 2012 feature)
995 * *AI-0195 Invalid value handling is implementation defined (2010-07-03)*
997 The handling of invalid values is now designated to be implementation
998 defined. This is a documentation change only, requiring Annex M in the GNAT
999 Reference Manual to document this handling.
1000 In GNAT, checks for invalid values are made
1001 only when necessary to avoid erroneous behavior. Operations like assignments
1002 which cannot cause erroneous behavior ignore the possibility of invalid
1003 values and do not do a check. The date given above applies only to the
1004 documentation change, this behavior has always been implemented by GNAT.
1006 RM References: 13.09.01 (10)
1008 .. index:: AI-0193 (Ada 2012 feature)
1010 * *AI-0193 Alignment of allocators (2010-09-16)*
1012 This AI introduces a new attribute `Max_Alignment_For_Allocation`,
1013 analogous to `Max_Size_In_Storage_Elements`, but for alignment instead
1016 RM References: 13.11 (16) 13.11 (21) 13.11.01 (0) 13.11.01 (1)
1017 13.11.01 (2) 13.11.01 (3)
1019 .. index:: AI-0177 (Ada 2012 feature)
1021 * *AI-0177 Parameterized expressions (2010-07-10)*
1023 The new Ada 2012 notion of parameterized expressions is implemented. The form
1028 function-specification is (expression)
1030 This is exactly equivalent to the
1031 corresponding function body that returns the expression, but it can appear
1032 in a package spec. Note that the expression must be parenthesized.
1034 RM References: 13.11.01 (3/2)
1036 .. index:: AI-0033 (Ada 2012 feature)
1038 * *AI-0033 Attach/Interrupt_Handler in generic (2010-07-24)*
1040 Neither of these two pragmas may appear within a generic template, because
1041 the generic might be instantiated at other than the library level.
1043 RM References: 13.11.02 (16) C.03.01 (7/2) C.03.01 (8/2)
1045 .. index:: AI-0161 (Ada 2012 feature)
1047 * *AI-0161 Restriction No_Default_Stream_Attributes (2010-09-11)*
1049 A new restriction `No_Default_Stream_Attributes` prevents the use of any
1050 of the default stream attributes for elementary types. If this restriction is
1051 in force, then it is necessary to provide explicit subprograms for any
1052 stream attributes used.
1054 RM References: 13.12.01 (4/2) 13.13.02 (40/2) 13.13.02 (52/2)
1056 .. index:: AI-0194 (Ada 2012 feature)
1058 * *AI-0194 Value of Stream_Size attribute (0000-00-00)*
1060 The `Stream_Size` attribute returns the default number of bits in the
1061 stream representation of the given type.
1062 This value is not affected by the presence
1063 of stream subprogram attributes for the type. GNAT has always implemented
1064 this interpretation.
1066 RM References: 13.13.02 (1.2/2)
1068 .. index:: AI-0109 (Ada 2012 feature)
1070 * *AI-0109 Redundant check in S'Class'Input (0000-00-00)*
1072 This AI is an editorial change only. It removes the need for a tag check
1073 that can never fail.
1075 RM References: 13.13.02 (34/2)
1077 .. index:: AI-0007 (Ada 2012 feature)
1079 * *AI-0007 Stream read and private scalar types (0000-00-00)*
1081 The RM as written appeared to limit the possibilities of declaring read
1082 attribute procedures for private scalar types. This limitation was not
1083 intended, and has never been enforced by GNAT.
1085 RM References: 13.13.02 (50/2) 13.13.02 (51/2)
1087 .. index:: AI-0065 (Ada 2012 feature)
1089 * *AI-0065 Remote access types and external streaming (0000-00-00)*
1091 This AI clarifies the fact that all remote access types support external
1092 streaming. This fixes an obvious oversight in the definition of the
1093 language, and GNAT always implemented the intended correct rules.
1095 RM References: 13.13.02 (52/2)
1097 .. index:: AI-0019 (Ada 2012 feature)
1099 * *AI-0019 Freezing of primitives for tagged types (0000-00-00)*
1101 The RM suggests that primitive subprograms of a specific tagged type are
1102 frozen when the tagged type is frozen. This would be an incompatible change
1103 and is not intended. GNAT has never attempted this kind of freezing and its
1104 behavior is consistent with the recommendation of this AI.
1106 RM References: 13.14 (2) 13.14 (3/1) 13.14 (8.1/1) 13.14 (10) 13.14 (14) 13.14 (15.1/2)
1108 .. index:: AI-0017 (Ada 2012 feature)
1110 * *AI-0017 Freezing and incomplete types (0000-00-00)*
1112 So-called 'Taft-amendment types' (i.e., types that are completed in package
1113 bodies) are not frozen by the occurrence of bodies in the
1114 enclosing declarative part. GNAT always implemented this properly.
1116 RM References: 13.14 (3/1)
1118 .. index:: AI-0060 (Ada 2012 feature)
1120 * *AI-0060 Extended definition of remote access types (0000-00-00)*
1122 This AI extends the definition of remote access types to include access
1123 to limited, synchronized, protected or task class-wide interface types.
1124 GNAT already implemented this extension.
1126 RM References: A (4) E.02.02 (9/1) E.02.02 (9.2/1) E.02.02 (14/2) E.02.02 (18)
1128 .. index:: AI-0114 (Ada 2012 feature)
1130 * *AI-0114 Classification of letters (0000-00-00)*
1132 The code points 170 (`FEMININE ORDINAL INDICATOR`),
1133 181 (`MICRO SIGN`), and
1134 186 (`MASCULINE ORDINAL INDICATOR`) are technically considered
1135 lower case letters by Unicode.
1136 However, they are not allowed in identifiers, and they
1137 return `False` to `Ada.Characters.Handling.Is_Letter/Is_Lower`.
1138 This behavior is consistent with that defined in Ada 95.
1140 RM References: A.03.02 (59) A.04.06 (7)
1142 .. index:: AI-0185 (Ada 2012 feature)
1144 * *AI-0185 Ada.Wide_[Wide_]Characters.Handling (2010-07-06)*
1146 Two new packages `Ada.Wide_[Wide_]Characters.Handling` provide
1147 classification functions for `Wide_Character` and
1148 `Wide_Wide_Character`, as well as providing
1149 case folding routines for `Wide_[Wide_]Character` and
1150 `Wide_[Wide_]String`.
1152 RM References: A.03.05 (0) A.03.06 (0)
1154 .. index:: AI-0031 (Ada 2012 feature)
1156 * *AI-0031 Add From parameter to Find_Token (2010-07-25)*
1158 A new version of `Find_Token` is added to all relevant string packages,
1159 with an extra parameter `From`. Instead of starting at the first
1160 character of the string, the search for a matching Token starts at the
1161 character indexed by the value of `From`.
1162 These procedures are available in all versions of Ada
1163 but if used in versions earlier than Ada 2012 they will generate a warning
1164 that an Ada 2012 subprogram is being used.
1166 RM References: A.04.03 (16) A.04.03 (67) A.04.03 (68/1) A.04.04 (51)
1169 .. index:: AI-0056 (Ada 2012 feature)
1171 * *AI-0056 Index on null string returns zero (0000-00-00)*
1173 The wording in the Ada 2005 RM implied an incompatible handling of the
1174 `Index` functions, resulting in raising an exception instead of
1175 returning zero in some situations.
1176 This was not intended and has been corrected.
1177 GNAT always returned zero, and is thus consistent with this AI.
1179 RM References: A.04.03 (56.2/2) A.04.03 (58.5/2)
1181 .. index:: AI-0137 (Ada 2012 feature)
1183 * *AI-0137 String encoding package (2010-03-25)*
1185 The packages `Ada.Strings.UTF_Encoding`, together with its child
1186 packages, `Conversions`, `Strings`, `Wide_Strings`,
1187 and `Wide_Wide_Strings` have been
1188 implemented. These packages (whose documentation can be found in the spec
1189 files :file:`a-stuten.ads`, :file:`a-suenco.ads`, :file:`a-suenst.ads`,
1190 :file:`a-suewst.ads`, :file:`a-suezst.ads`) allow encoding and decoding of
1191 `String`, `Wide_String`, and `Wide_Wide_String`
1192 values using UTF coding schemes (including UTF-8, UTF-16LE, UTF-16BE, and
1193 UTF-16), as well as conversions between the different UTF encodings. With
1194 the exception of `Wide_Wide_Strings`, these packages are available in
1195 Ada 95 and Ada 2005 mode as well as Ada 2012 mode.
1196 The `Wide_Wide_Strings package`
1197 is available in Ada 2005 mode as well as Ada 2012 mode (but not in Ada 95
1198 mode since it uses `Wide_Wide_Character`).
1200 RM References: A.04.11
1202 .. index:: AI-0038 (Ada 2012 feature)
1204 * *AI-0038 Minor errors in Text_IO (0000-00-00)*
1206 These are minor errors in the description on three points. The intent on
1207 all these points has always been clear, and GNAT has always implemented the
1208 correct intended semantics.
1210 RM References: A.10.05 (37) A.10.07 (8/1) A.10.07 (10) A.10.07 (12) A.10.08 (10) A.10.08 (24)
1212 .. index:: AI-0044 (Ada 2012 feature)
1214 * *AI-0044 Restrictions on container instantiations (0000-00-00)*
1216 This AI places restrictions on allowed instantiations of generic containers.
1217 These restrictions are not checked by the compiler, so there is nothing to
1218 change in the implementation. This affects only the RM documentation.
1220 RM References: A.18 (4/2) A.18.02 (231/2) A.18.03 (145/2) A.18.06 (56/2) A.18.08 (66/2) A.18.09 (79/2) A.18.26 (5/2) A.18.26 (9/2)
1222 .. index:: AI-0127 (Ada 2012 feature)
1224 * *AI-0127 Adding Locale Capabilities (2010-09-29)*
1226 This package provides an interface for identifying the current locale.
1228 RM References: A.19 A.19.01 A.19.02 A.19.03 A.19.05 A.19.06
1229 A.19.07 A.19.08 A.19.09 A.19.10 A.19.11 A.19.12 A.19.13
1231 .. index:: AI-0002 (Ada 2012 feature)
1233 * *AI-0002 Export C with unconstrained arrays (0000-00-00)*
1235 The compiler is not required to support exporting an Ada subprogram with
1236 convention C if there are parameters or a return type of an unconstrained
1237 array type (such as `String`). GNAT allows such declarations but
1238 generates warnings. It is possible, but complicated, to write the
1239 corresponding C code and certainly such code would be specific to GNAT and
1242 RM References: B.01 (17) B.03 (62) B.03 (71.1/2)
1244 .. index:: AI05-0216 (Ada 2012 feature)
1246 * *AI-0216 No_Task_Hierarchy forbids local tasks (0000-00-00)*
1248 It is clearly the intention that `No_Task_Hierarchy` is intended to
1249 forbid tasks declared locally within subprograms, or functions returning task
1250 objects, and that is the implementation that GNAT has always provided.
1251 However the language in the RM was not sufficiently clear on this point.
1252 Thus this is a documentation change in the RM only.
1254 RM References: D.07 (3/3)
1256 .. index:: AI-0211 (Ada 2012 feature)
1258 * *AI-0211 No_Relative_Delays forbids Set_Handler use (2010-07-09)*
1260 The restriction `No_Relative_Delays` forbids any calls to the subprogram
1261 `Ada.Real_Time.Timing_Events.Set_Handler`.
1263 RM References: D.07 (5) D.07 (10/2) D.07 (10.4/2) D.07 (10.7/2)
1265 .. index:: AI-0190 (Ada 2012 feature)
1267 * *AI-0190 pragma Default_Storage_Pool (2010-09-15)*
1269 This AI introduces a new pragma `Default_Storage_Pool`, which can be
1270 used to control storage pools globally.
1271 In particular, you can force every access
1272 type that is used for allocation (**new**) to have an explicit storage pool,
1273 or you can declare a pool globally to be used for all access types that lack
1276 RM References: D.07 (8)
1278 .. index:: AI-0189 (Ada 2012 feature)
1280 * *AI-0189 No_Allocators_After_Elaboration (2010-01-23)*
1282 This AI introduces a new restriction `No_Allocators_After_Elaboration`,
1283 which says that no dynamic allocation will occur once elaboration is
1285 In general this requires a run-time check, which is not required, and which
1286 GNAT does not attempt. But the static cases of allocators in a task body or
1287 in the body of the main program are detected and flagged at compile or bind
1290 RM References: D.07 (19.1/2) H.04 (23.3/2)
1292 .. index:: AI-0171 (Ada 2012 feature)
1294 * *AI-0171 Pragma CPU and Ravenscar Profile (2010-09-24)*
1296 A new package `System.Multiprocessors` is added, together with the
1297 definition of pragma `CPU` for controlling task affinity. A new no
1298 dependence restriction, on `System.Multiprocessors.Dispatching_Domains`,
1299 is added to the Ravenscar profile.
1301 RM References: D.13.01 (4/2) D.16
1303 .. index:: AI-0210 (Ada 2012 feature)
1305 * *AI-0210 Correct Timing_Events metric (0000-00-00)*
1307 This is a documentation only issue regarding wording of metric requirements,
1308 that does not affect the implementation of the compiler.
1310 RM References: D.15 (24/2)
1312 .. index:: AI-0206 (Ada 2012 feature)
1314 * *AI-0206 Remote types packages and preelaborate (2010-07-24)*
1316 Remote types packages are now allowed to depend on preelaborated packages.
1317 This was formerly considered illegal.
1319 RM References: E.02.02 (6)
1321 .. index:: AI-0152 (Ada 2012 feature)
1323 * *AI-0152 Restriction No_Anonymous_Allocators (2010-09-08)*
1325 Restriction `No_Anonymous_Allocators` prevents the use of allocators
1326 where the type of the returned value is an anonymous access type.
1328 RM References: H.04 (8/1)