4.9 Static Expressions and Static Subtypes

Discussion: As opposed to more elaborate data flow analysis, etc. 

For an expression to be static, it has to be calculable at compile time.

Only scalar and string expressions are static.

To be static, an expression cannot have any nonscalar, nonstring subexpressions (though it can have nonscalar constituent names). A static scalar expression cannot have any nonscalar subexpressions. There is one exception — a membership test for a string subtype can be static, and the result is scalar, even though a subexpression is nonscalar.

The rules for evaluating static expressions are designed to maximize portability of static calculations. 

Ramification: A numeric_literal is always a static expression, even if its expected type is not that of a static subtype. However, if its value is explicitly converted to, or qualified by, a nonstatic subtype, the resulting expression is nonstatic.

Ramification: That is, the constrained subtype defined by the index range of the string is static. Note that elementary values don't generally have subtypes, while composite values do (since the bounds or discriminants are inherent in the value). 

Ramification: Note that enumeration literals are covered by the function_call case. 

Ramification: This includes uses of operators that are equivalent to function_calls.

Ramification: Note that this does not include the case of an attribute that is a function; a reference to such an attribute is not even an expression. See above for function calls.

An implementation may define the staticness and other properties of implementation-defined attributes. 

Ramification: This rules out the subtype_mark'aggregate case. 

Reason: Adding qualification to an expression shouldn't make it nonstatic, even for strings. 

Reason: Clearly, we should allow membership tests in exactly the same cases where we allow qualified_expressions.

Discussion: Informally, we talk about a static value. When we do, we mean a value specified by a static expression. 

Ramification: The language requires a static expression in a number_declaration, a numeric type definition, a discrete_choice (sometimes), certain representation items, an attribute_designator, and when specifying the value of a discriminant governing a variant_part in a record_aggregate or extension_aggregate.

Ramification: Selected_components that are not expanded names and indexed_components do not statically denote things. 

Ramification: These are the functions whose calls can be static expressions. 

Ramification: A deferred constant is not static; the view introduced by the corresponding full constant declaration can be static. 

Reason: {AI05-0229-1} The reason for restricting the length of static string constants is so that compilers don't have to store giant strings in their symbol tables. Since most string constants will be initialized from string_literals, the length limit seems pretty natural. The reason for avoiding nonstring types is also to save symbol table space. We're trying to keep it cheap and simple (from the implementer's viewpoint), while still allowing, for example, the aspect_definition for a Link_Name aspect link name of a pragma Import to contain a concatenation.

The length we're talking about is the maximum number of characters in the value represented by a string_literal, not the number of characters in the source representation; the quotes don't count.

Ramification: String subtypes are the only composite subtypes that can be static. 

Reason: The part about generic formal objects of mode in out is necessary because the subtype of the formal is not required to have anything to do with the subtype of the actual. For example: 

The case_statement is illegal, because the subtype of F is not static, so the choices have to cover all values of Integer, not just those in the range 1..10. A similar issue arises for generic formal functions, now that function calls are object names. 

Reason: We need this bullet so that only a single dependent_expression is evaluated in a static if_expression if there is more than one condition that evaluates to True. The part about conditions makes 

legal if N and Min are static and N = 0. 

Discussion: {AI05-0147-1} {AI05-0188-1} We need the "of the if_expression" here so there is no confusion for nested if_expressions; this rule only applies to the conditions and dependent_expressions of a single if_expression. Similar reasoning applies to the "of a case_expression" of the last bullet. 

Reason: {AI05-0262-1} Assertion policies can control whether checks are made, but we don't want assertion policies to affect legality. For Ada 2012, subtype predicates are the only checks controlled by the assertion policy that can appear in static expressions. 

Ramification: {AI95-00269-01} If the expression is expected to be of a universal type, or of “any integer type”, there are no limits on the value of the expression. 

Ramification: This means that a numeric_literal for a decimal type cannot have “extra” significant digits.

Reason: {AI95-00269-01} The small is not known for a generic formal type, so we have to exclude formal types from this check. 

Discussion: Values outside the base range are not permitted when crossing from the “static” domain to the “dynamic” domain. This rule is designed to enhance portability of programs containing static expressions. Note that this rule applies to the exact value, not the value after any rounding or truncation. (See below for the rounding and truncation requirements.)

Short-circuit control forms are a special case: 

The declaration of X is legal, since the divide-by-zero part of the expression is not evaluated. X is a static constant equal to True.

Ramification: {AI95-00269-01} There is no requirement to recheck these rules in an instance; the base range check will generally be performed at run time anyway. 

Reason: {AI95-00268-01} Discarding extended precision enhances portability by ensuring that the value of a static constant of a real type is always a machine number of the type. Deterministic rounding of exact halves also enhances portability.

When the expected type is a descendant of a formal floating point type, extended precision (beyond that of the machine numbers) can be retained when evaluating a static expression, to ease code sharing for generic instantiations. For similar reasons, normal (nondeterministic) rounding or truncating rules apply for descendants of a formal fixed point type.

{AI95-00269-01} There is no requirement for exact evaluation or special rounding in an instance body (unless the expression is static in the generic body). This eliminates a potential contract issue where the exact value of a static expression depends on the actual parameters (which could then affect the legality of other code). 

Implementation Note: Note that the implementation of static expressions has to keep track of plus and minus zero for a type whose Signed_Zeros attribute is True.

{AI95-00100-01} Note that the only machine numbers values of a fixed point type are the multiples of the small, so a static conversion to a fixed-point type, or division by an integer, must do truncation to a multiple of small. It is not correct for the implementation to do all static calculations in infinite precision.

Ramification: For example: 

The expression is static, which means that the value of X must be exactly 1.0, independent of the accuracy or range of the run-time floating point implementation.

The following kinds of expressions are never static: explicit_dereference, indexed_component, slice, null, aggregate, allocator.

Reason: We specify this for portability. The reason for not choosing round-to-nearest-even, for example, is that this method is easier to undo. 

Ramification: The attribute Truncation (see A.5.3) can be used to perform a (static) truncation prior to conversion, to prevent rounding. 

Implementation Note: The value of the literal 0E999999999999999999999999999999999999999999999 is zero. The implementation must take care to evaluate such literals properly.

The rules for static expressions and static subtypes are generalized to allow more kinds of compile-time-known expressions to be used where compile-time-known values are required, as follows: 

The rules for the evaluation of static expressions are revised to require exact evaluation at compile time, and force a machine number result when crossing from the static realm to the dynamic realm, to enhance portability and predictability. Exact evaluation is not required for descendants of a formal scalar type, to simplify generic code sharing and to avoid generic contract model problems.

Static expressions are legal even if an intermediate in the expression goes outside the base range of the type. Therefore, the following will succeed in Ada 95, whereas it might raise an exception in Ada 83: 

This might raise an exception in Ada 83 because "32_768" is out of range, even though "–32_768" is not. In Ada 95, this will always succeed.

Certain expressions involving string operations (in particular concatenation and membership tests) are considered static in Ada 95.

The reason for this change is to simplify the rule requiring compile-time-known string expressions as the link name in an interfacing pragma, and to simplify the preelaborability rules.

An Ada 83 program that uses an out-of-range static value is illegal in Ada 95, unless the expression is part of a larger static expression, or the expression is not evaluated due to being on the right-hand side of a short-circuit control form.

This clause (and 4.5.5, “Multiplying Operators”) subsumes the RM83 section on Universal Expressions.

The existence of static string expressions necessitated changing the definition of static subtype to include string subtypes. Most occurrences of "static subtype" have been changed to "static scalar subtype", in order to preserve the effect of the Ada 83 rules. This has the added benefit of clarifying the difference between "static subtype" and "statically constrained subtype", which has been a source of confusion. In cases where we allow static string subtypes, we explicitly use phrases like "static string subtype" or "static (scalar or string) subtype", in order to clarify the meaning for those who have gotten used to the Ada 83 terminology.

In Ada 83, an expression was considered nonstatic if it raised an exception. Thus, for example: 

was illegal because 1/0 was not static. In Ada 95, the above example is still illegal, but for a different reason: 1/0 is static, but there's a separate rule forbidding the exception raising.

{AI95-00268-01} Amendment Correction: Rounding of static real expressions is implementation-defined in Ada 2005, while it was specified as away from zero in (original) Ada 95. This could make subtle differences in programs. However, the original Ada 95 rule required rounding that (probably) differed from the target processor, thus creating anomalies where the value of a static expression was required to be different than the same expression evaluated at run-time.

{AI95-00263-01} {AI95-00268-01} The Ada 95 wording that defined static subtypes unintentionally failed to exclude formal derived types that happen to be scalar (these aren't formal scalar types); and had a parenthetical remark excluding formal string types - but that was neither necessary nor parenthetical (it didn't follow from other wording). This issue also applies to the rounding rules for real static expressions.

{AI95-00269-01} Ada 95 didn't clearly define the bounds of a value of a static expression for universal types and for "any integer/float/fixed type". We also make it clear that we do not intend exact evaluation of static expressions in an instance body if the expressions aren't static in the generic body.

{AI95-00311-01} We clarify that the first subtype of a scalar formal type has a nonstatic, non-null constraint. 

{AI05-0147-1} {AI05-0188-1} Added wording to define staticness and the lack of evaluation for if_expressions and case_expressions. These are new and defined elsewhere.

{AI05-0153-3} Added wording to prevent subtypes that have dynamic predicates (see 3.2.4) from being static.

{AI05-0158-1} Revised wording for membership tests to allow for the new possibilities allowed by the membership_choice_list.