Require an integer value constant for a behavior array size and keep it unevaluated 🤖

[lwrage]

Fixes #3208
Fixes #3210

This branch carries both defects, since they are the same declaration read two ways: what the grammar accepts as an array size, and what translation does with the size it accepted.

Cause and correction

#3208 — AS5506/3 Rev A D.3 writes a behavior variable array size as the D.7 integer value constant. The shared integer-value grammar also accepts an ordinary reference expression, which names a value variable rather than a constant, and no strict checker constrains an array size. BehaviorAnnexValidator.checkArraySizes now reports a reference expression with no property tail, so the illegal form is rejected rather than silently turned into a zero extent.

#3210 — aadl2::ArraySize carries either a literal extent or a property constant, so a property reference had nowhere to go. Translation compensated by evaluating an element-prefixed reference against the declarative model and storing the number it read. That answers a per-instance question at declarative translation time, and declarative property lookup sees only the element's own associations, the single-element contained associations of its immediate containing classifier, and the property default (NamedElementImpl.getPropertyValueInternal → PropertyAcc.addLocalContained). A contained association with a longer path, or one declared further up, is invisible to it and belongs to the instance model, so the extent was either rejected as unavailable or frozen at a value the instance model contradicts.

The correction adds BehaviorArraySize to the strict Behavior Annex metamodel, a subclass of aadl2::ArraySize that owns the size as a BA IntegerValue the way BehaviorTime owns the value of a behavior time. Translation now routes the declared size through the same toIntegerValue every other integer value position uses, so a property reference keeps its own form, prefix, indexes, and fields included. Subclassing rather than replacing the dimension keeps a behavior variable an ArrayableElement, so AadlBaUtils and AadlUtil.getElementCount keep working, and the inherited extent is still set for the two forms core AADL can express: an integer literal and an unindexed property constant. Validation no longer asks whether the declarative model can supply a value, since that is not a question about the legality of the declaration.

Reading the branch commit by commit, note that a939c9d87e introduced the element-prefixed evaluation and eb16aaf6b4 removes it again; the net diff is the unevaluated representation.

8765cbc1d2 then removes property value readers in org.osate.utils.internal.PropertyUtils that nothing in the reactor calls: twenty-two public methods and the private getUnit helper only setFloatValue used. The eight methods the Behavior Annex uses stay.

Regression models and assertions

• models/issue3208/ — an array size written as a reference expression with no property tail; asserts the D.3 error.
• models/issue3210/Issue3210.aadl — byLiteral[8], byConstant[# AADL_Project::Max_Queue_Size], byPrefixed[input#Queue_Size]. Asserts that the literal and the constant also reach the inherited aadl2::ArraySize extent, and that the prefixed reference keeps its own form as a ClassifierFeaturePropertyReference naming input and Queue_Size with the core extent left unset. The prefixed feature declares Queue_Size => 8, so a translation that read the property would have frozen that 8.
• models/issue3210/BareProperty.aadl — a bare property definition as a size; now accepted and kept as a PropertySetPropertyReference.
• models/issue3210/ContainedProperty.aadl — the extent comes from Queue_Size => 16 applies to worker.input in the enclosing process implementation, a two-element containment path. Declarative lookup cannot see it and answered with the property default of 1; the assertion requires the reference to be kept with no extent read.

Corpus goldens are regenerated. The resolved-model projections change shape (size : BehaviorArraySize with its integerValue child) for every model with an array dimension, and BareProperty's validated diagnostics lose the evaluability error.

Validation

Clean root reactor, run outside the sandbox:

mvn -s releng/osate.releng/settings.xml -Plocal -T5 \
  -Dtycho.localArtifacts=ignore -Dpr.build=true -Dsign=false \
  -Dspotbugs=false -Dcodecoverage=false -Djavadoc=false \
  -DfailIfNoTests=false clean install

BUILD SUCCESS, 143 modules, no failures or errors. org.osate.ba.tests: 119 tests, 0 failures, 5 pre-existing conformance skips, including Issue3210Test (4) and Issue3176Test (3). Goldens verified with regeneration off after regenerating.

Dependencies and merge order

No dependency on an unmerged change; the branch is based on master at d2899cc7a4. PR for #3211 is based on this branch and should merge after it.

Residual risk

This PR removes exported API and does not carry the version change. org.osate.utils.internal is exported, and org.osate.ba re-exports the requirement, so the twenty-two removed public methods were reachable by external Behavior Annex tooling. org.osate.utils is at 2.1.0 and both requiring bundles ask for [2.1.0,3.0.0); a major bump to 3.0.0 with the consumer ranges widened is required through releng/version-management/ before merge, and is deliberately not hand-edited here.

Other risks:

• The metamodel gains an EClass, so the aadlba classifier IDs after it shift. That is generated renumbering, not a source change, but anything binding to those integers rather than to AadlBaPackage.Literals would need rebuilding.
• For a property-reference size the core-level extent stays unset, so a consumer reading a dimension the core way sees no extent where it previously saw an evaluated number for the element-prefixed form. Resolving that value belongs to instantiation.
• BehaviorArraySizeImpl.getAadlBaLocationReference is hand-written in generated code, as in every BA implementation that extends an aadl2 implementation, and must survive future regeneration.

🤖 Generated with Claude Code