[2.3] Work the resolution-position slice: size it, clear one with a test

The slice named this morning, sized: 80 sites, concentrated in
ValidationPass (35), UseCaseWitnessPass (9), JsonifierPass (7) and
AST.scala (7).

First one examined is `ResolutionPass.valueScopeField`'s `aggFields`,
and it was a strong suspect on precedent: it reads a Type's fields and
answers `Seq.empty` for anything that is not an
AggregateTypeExpression, so it cannot see through an alias — exactly
the defect `isAddressFieldFor` had, fixed in ccd278c because aliasing
is riddl-models' house style.

It is NOT a defect. An aliased state record resolves exactly as a
direct one, because `valueScopeField` is not the only route: the A55
ValueRef walk reaches the field anyway. So the empty is the "nothing to
do here" kind the rule permits.

`AliasedValueScopeTest` keeps both forms green, which is worth more
than the verdict: if a future change ever makes `valueScopeField` the
sole route, this reddens instead of riddl-models reddening.

The method note is the point. Reasoning from "this shape was a defect
over there" got the site onto the list and was still wrong about it —
only running it settled the question. Same lesson as [2.6]'s
unreachable arm, from the other direction.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: reid-spencer

BACKLOG.md

@@ -857,8 +857,28 @@ that needs a ruling before either can be fixed.
   **That is the whole output-producing slice.** `RiddlAPI.scala:156` carries its
   own justification (Comment/Include have no identifier).
 
-  **The remaining ~185 are unexamined.** Next slice, by the same "cheap to size"
-  logic: `case _ => None` and `case _ => Seq.empty` in RESOLUTION positions,
+  **AUDIT PROGRESS 2026-08-18 — the resolution-position slice, sized and started.**
+  `grep -rn -E "case _ *=> *(None|Seq\.empty|Nil)"` over `passes`/`language`/
+  `riddlLib` returns **80 sites**, concentrated in `ValidationPass` (35),
+  `UseCaseWitnessPass` (9), `JsonifierPass` (7) and `AST.scala` (7).
+  **EXAMINED AND CLEARED, with a test rather than an opinion:**
+  `ResolutionPass.valueScopeField`'s `aggFields` (`:724`) — it reads a Type's
+  fields and answers `Seq.empty` for anything that is not an
+  `AggregateTypeExpression`, which does NOT see through an alias. That made it a
+  strong suspect, since `isAddressFieldFor` had exactly this defect and was taught
+  to follow alias chains in `ccd278c00` because aliasing is riddl-models' house
+  style. **It is not a defect**: an aliased state record resolves exactly as a
+  direct one, because `valueScopeField` is not the only route — the A55 `ValueRef`
+  walk reaches the field anyway. `AliasedValueScopeTest` pins both forms, so a
+  future change that made `valueScopeField` the sole route reddens here instead of
+  reddening riddl-models.
+  **Method note worth keeping: the suspicion was well-founded and still wrong.**
+  Reasoning from "this shape was a defect over there" got the site onto the list;
+  only running it settled the question. That is the same lesson as [2.6]'s
+  unreachable arm, in the opposite direction.
+
+  **The remaining ~78 are unexamined.** Continue with the same
+  slice: `case _ => None` and `case _ => Seq.empty` in RESOLUTION positions,
   where an empty answer is read downstream as "no such thing" — the shape that
   produced both of this week's found defects (`DependencyAnalysisPass.typeDeps`
   empty forever, `MessageFlowPass` dropping let-local edges). Neither of those

passes/src/test/scala-jvm-native/com/ossuminc/riddl/passes/resolve/AliasedValueScopeTest.scala

@@ -0,0 +1,115 @@
+/*
+ * Copyright 2019-2026 Ossum Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package com.ossuminc.riddl.passes.resolve
+
+import com.ossuminc.riddl.language.Messages
+import com.ossuminc.riddl.language.parsing.RiddlParserInput
+import com.ossuminc.riddl.passes.validate.AbstractValidatingTest
+import com.ossuminc.riddl.utils.pc
+
+import org.scalatest.TestData
+
+/** [2.3]: `ResolutionPass.valueScopeField`'s `aggFields` reads a Type's fields with
+  * `case ate: AggregateTypeExpression => ate.fields; case _ => Seq.empty` — an empty answer in a
+  * RESOLUTION position, which downstream reads as "no such field".
+  *
+  * The question this pins is whether that empty is reachable through an ALIAS. `isAddressFieldFor`
+  * had exactly this defect and was taught to follow alias chains in `ccd278c00`, on the grounds
+  * that aliasing is riddl-models' documented house style — so the shape was a strong suspect.
+  *
+  * **VERDICT 2026-08-18: NOT a defect, and this suite is the evidence.** An aliased state record
+  * resolves exactly as a direct one does, because `valueScopeField` is not the only route — the
+  * A55 `ValueRef` walk reaches the field anyway. So the `case _ => Seq.empty` is the "nothing to do
+  * here" kind the no-silent-fall-through rule explicitly permits, not the "I do not know what this
+  * is" kind.
+  *
+  * Kept rather than deleted: it costs nothing and it pins the ONE thing that would make the empty
+  * bite — a future change that made `valueScopeField` the sole route would turn these green cases
+  * red instead of turning riddl-models red.
+  */
+class AliasedValueScopeTest extends AbstractValidatingTest {
+
+  private def errorsFor(src: String, td: TestData): Messages.Messages =
+    var captured: Messages.Messages = Messages.empty
+    parseAndValidateInput(RiddlParserInput(src, td), shouldFailOnErrors = false) {
+      case (_, _, msgs) => captured = msgs; succeed
+    }
+    captured
+
+  "a bare value reference to a field of an ALIASED handled message" should {
+    "resolve" in { (td: TestData) =>
+      val src =
+        """domain D is {
+          |  context C is {
+          |    command Direct is { amount: Real }
+          |    entity E is {
+          |      handler H is {
+          |        on command D.C.Direct is {
+          |          let a = amount
+          |          do "use it"
+          |        }
+          |      }
+          |    }
+          |  }
+          |}
+          |""".stripMargin
+      val errs = errorsFor(src, td).justErrors
+      withClue(s"CONTROL (no alias) messages:\n${errorsFor(src, td).format}\n") {
+        errs mustBe empty
+      }
+    }
+  }
+
+  "a bare value reference to a field of an ALIASED entity state record" should {
+    "resolve, exactly as it does when the state names the record directly" in { (td: TestData) =>
+      val direct =
+        """domain D is {
+          |  context C is {
+          |    command Touch is { ??? }
+          |    record OrderData is { total: Real }
+          |    entity E is {
+          |      state main of record D.C.OrderData
+          |      handler H is {
+          |        on command D.C.Touch is {
+          |          let t = total
+          |          do "use it"
+          |        }
+          |      }
+          |    }
+          |  }
+          |}
+          |""".stripMargin
+      val aliased =
+        """domain D is {
+          |  context C is {
+          |    command Touch is { ??? }
+          |    record OrderData is { total: Real }
+          |    type OrderState is D.C.OrderData
+          |    entity E is {
+          |      state main of record D.C.OrderState
+          |      handler H is {
+          |        on command D.C.Touch is {
+          |          let t = total
+          |          do "use it"
+          |        }
+          |      }
+          |    }
+          |  }
+          |}
+          |""".stripMargin
+
+      val directErrs = errorsFor(direct, td).justErrors
+      withClue(s"DIRECT form messages:\n${errorsFor(direct, td).format}\n") {
+        directErrs mustBe empty
+      }
+      val aliasErrs = errorsFor(aliased, td).justErrors
+      withClue(s"ALIASED form messages:\n${errorsFor(aliased, td).format}\n") {
+        aliasErrs mustBe empty
+      }
+    }
+  }
+}