[1.16] A rule may carry a computed fix; [1.18] the JS logger override is gone

**1.16**: `mechanicalFix` was `Option[String]` -- a CONSTANT -- so a fix whose
replacement depends on what it matched could not be written at all.
`quoted-constant-literal` (`constant N: Integer = "5"` -> `5`) is a pure span
replacement and was excluded purely for want of a way to say so.

`Fix` is a sum type rather than a second field beside the old one, because two fields
describing one fix can disagree. The distinction earns its keep: a CONSTANT fix is
expressible in the published `Map[String, String]` that RiddlLib and DeprecationCode
hand to consumers, and a COMPUTED one is not. So the map keeps only constants and says
why, while `validate --fix` -- which has the matched span -- applies both.
`deprecationEdits` applies computed fixes too, by slicing the span out of the source it
already holds.

`"1.50"` becomes `1.50`, not `1.5`. A constant replacement could never have done that,
and a parse-and-reprint would have silently dropped the precision the author wrote.

**1.18**: `DOMPlatformContext.log` returned a FRESH `SysLogger()` on every call. The
known symptom was that `withLogger` could not capture on JS. The unnoticed one is that
`Logger` holds per-instance counters, so every `count()` landed on a discarded object
and `Logger.summary` reported zero on JS for as long as the override stood. And it
returned exactly what the base field is already initialised to -- so deleting it fixes
both while changing nothing about default behaviour.

`RuleIdLogRenderingTest` moves back to SHARED test scala, where it now passes on JS.
That matters more than the line count: the defect was a PLATFORM difference, and a
suite that skips the platform it differs on cannot see it return. A new
`LoggerIdentityTest` asserts the logger is the same instance across calls and that
counts accumulate; both were canary-tested by restoring the override on JS.

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

Author: reid-spencer

BACKLOG.md

@@ -1070,7 +1070,12 @@ verification is carried here so it is not repeated.**
   Do NOT simply rename it.
 
 
-- **[1.16]** **A codemod whose replacement is COMPUTED from the matched text.**
+- ~~**[1.16]** **A codemod whose replacement is COMPUTED from the matched text.**~~ — **DONE
+  2026-08-26.** `Fix` is a sum type (`Constant` | `Computed`), so the published
+  `Map[String, String]` keeps only what it can express and `validate --fix` applies both.
+  `quoted-constant-literal` now fixes. Original entry follows.
+
+  **[1.16 — as filed]**
   `RuleId.mechanicalFix` is an `Option[String]` -- a CONSTANT replacement -- which covers
   `prompt-statement` -> `do` and `abstract-type` -> `Anything` and cannot express a fix that
   depends on what it matched.
@@ -1092,7 +1097,11 @@ verification is carried here so it is not repeated.**
   at every layer so no corpus model moves. FORMAT_REVISION 23. Riddlg was the requester.
 
 
-- **[1.18]** **`withLogger` is a silent no-op on Scala.js.**
+- ~~**[1.18]** **`withLogger` is a silent no-op on Scala.js.**~~ — **DONE 2026-08-26**: the
+  override is deleted. It also zeroed every message counter, which nobody had noticed.
+  Original entry follows.
+
+  **[1.18 — as filed]**
   **Verified**: `DOMPlatformContext.scala:88` overrides `def log: Logger = SysLogger()`, returning
   a FRESH logger on every call, so the logger `PlatformContext.withLogger` swaps into the `logger`
   field is never consulted. `pc.withLogger(CallBackLogger(...)) { ... }` therefore captures nothing

commands/src/main/scala/com/ossuminc/riddl/commands/ValidateCommand.scala

@@ -8,7 +8,7 @@ package com.ossuminc.riddl.commands
 
 import com.ossuminc.riddl.command.{Command, CommandOptions}
 import com.ossuminc.riddl.commands.find.FindEditor
-import com.ossuminc.riddl.language.{Messages, RuleId}
+import com.ossuminc.riddl.language.{Fix, Messages, RuleId}
 import com.ossuminc.riddl.language.Messages.Messages
 import com.ossuminc.riddl.language.parsing.RiddlParserInput
 import com.ossuminc.riddl.passes.{PassesResult, Riddl}
@@ -181,7 +181,7 @@ class ValidateCommand(using pc: PlatformContext)
     // Every diagnostic is classified, so the report can say what it did NOT fix and why. Their
     // design note is the reason this is not optional: "a codemod that silently leaves 40 sites is
     // worse than one that fixes none".
-    val fixable = scala.collection.mutable.ListBuffer.empty[(Messages.Message, RuleId, String)]
+    val fixable = scala.collection.mutable.ListBuffer.empty[(Messages.Message, RuleId, Fix)]
     // Grouped by REASON, listing the rules -- not one line per rule. The reason text is identical
     // for every rule lacking a fix, so a line each turned a 20-finding model into 11 lines of the
     // same sentence and buried the one that mattered.
@@ -205,10 +205,10 @@ class ValidateCommand(using pc: PlatformContext)
                     "reported span",
                   rule.code
                 )
-              case Some(replacement) =>
+              case Some(fix) =>
                 FindEditor.fileOfSource(m.loc.source) match
                   case None    => skip("not in a file this run can edit", rule.code)
-                  case Some(_) => fixable.append((m, rule, replacement))
+                  case Some(_) => fixable.append((m, rule, fix))
     }
 
     def reportSkips(label: String): Unit =
@@ -233,10 +233,15 @@ class ValidateCommand(using pc: PlatformContext)
       // `fileOfSource`, NOT `Path.of(loc.source.origin)`: origin is the SHORT name error messages
       // render, so treating it as a path works only when the cwd happens to be the model's own
       // directory. `find -replace` shipped with exactly that bug.
-      val edits = fixable.toSeq.flatMap { case (m, rule, replacement) =>
+      val edits = fixable.toSeq.flatMap { case (m, rule, fix) =>
         FindEditor
           .fileOfSource(m.loc.source)
-          .map(file => FindEditor.Edit(file, m.loc.offset, m.loc.endOffset, replacement, rule.code))
+          .map { file =>
+            // A COMPUTED fix is applied against the text it matched, which the message's own span
+            // identifies. `quoted-constant-literal` (`"5"` -> `5`) is only expressible this way.
+            val matched = m.loc.source.data.slice(m.loc.offset, m.loc.endOffset)
+            FindEditor.Edit(file, m.loc.offset, m.loc.endOffset, fix(matched), rule.code)
+          }
       }
       FindEditor.plan(edits) match
         case Left(problems) =>

commands/src/test/scala-jvm-native/com/ossuminc/riddl/commands/ValidateFixTest.scala

@@ -129,6 +129,40 @@ class ValidateFixTest extends AnyWordSpec with Matchers {
     }
   }
 
+  "a COMPUTED fix" should {
+
+    "rewrite the span using the text it matched" in {
+      // [1.16]: `mechanicalFix` was `Option[String]` -- a CONSTANT -- so a fix whose replacement
+      // depends on what it matched could not be expressed at all. `quoted-constant-literal` is a
+      // pure span replacement (`"5"` -> `5`) and was excluded purely for want of a way to say so.
+      val model =
+        """domain D is {
+          |  context C is {
+          |    constant Threshold: Integer = "5"
+          |    constant Ratio: Real = "1.50"
+          |  } with { briefly "c" described as "c" }
+          |} with { briefly "d" described as "d" }
+          |""".stripMargin
+      withModel(model) { (run, read) =>
+        run(ValidateCommand.Options(fix = true))
+        val after = read()
+        after must include("constant Threshold: Integer = 5")
+        // `1.50`, not `1.5`: the replacement is the matched text minus its quotes, so precision
+        // written by the author survives. A parsed-and-reprinted number would not.
+        after must include("constant Ratio: Real = 1.50")
+        after mustNot include("\"5\"")
+      }
+    }
+
+    "not appear in the constant-replacement map, which cannot carry it" in {
+      // The published Map[String, String] is handed to consumers that apply replacements blindly.
+      // A computed fix has no constant text, so omitting it is the honest answer rather than
+      // inventing one.
+      RuleId.mechanicalReplacements.keySet mustNot contain(RuleId.QuotedConstantLiteral.code)
+      RuleId.fixable.keySet must contain(RuleId.QuotedConstantLiteral.code)
+    }
+  }
+
   "the fixable set" should {
     "contain only rules whose fix is a pure span replacement" in {
       // shape-keyword rewrites `flow X is` to `processor X as flow is` -- an insertion elsewhere

language/src/main/scala/com/ossuminc/riddl/language/RuleId.scala

@@ -42,16 +42,52 @@ package com.ossuminc.riddl.language
   * @param code
   *   The stable, published identifier. Kebab-case, subject-prefixed.
   * @param mechanicalFix
-  *   Replacement text when this rule's fix is a pure SPAN REPLACEMENT -- the message's `loc` covers
-  *   exactly the offending source and swapping in this text resolves it, touching nothing else.
-  *   `None` when the fix needs a judgement call or a rewrite somewhere other than the span.
+  *   How to rewrite the span when this rule's fix is a pure SPAN REPLACEMENT -- the message's `loc`
+  *   covers exactly the offending source and swapping in the result resolves it, touching nothing
+  *   else. `None` when the fix needs a judgement call or a rewrite somewhere other than the span.
   * @param deprecates
   *   True when the rule reports a deprecated construct. Kept ON THE RULE so the set of deprecations
   *   is derived rather than listed; see the note on `DeprecationCode.all` above.
   */
+/** How a rule's fix produces its replacement text.
+  *
+  * A sum type rather than a second field beside `Option[String]`: two fields describing one fix can
+  * disagree, and this repo keeps recording that shape as a defect.
+  *
+  * The distinction is real, not bookkeeping. A CONSTANT fix is expressible in the published
+  * `Map[String, String]` that `RiddlLib.deprecationEdits` and `DeprecationCode.mechanicalReplacement`
+  * hand to consumers; a COMPUTED one is not, because it needs the matched text. Keeping them
+  * separate is what lets that map stay honest about what it can carry instead of silently omitting
+  * or mis-stating the computed ones.
+  */
+enum Fix:
+
+  /** The span is replaced by this exact text, whatever it matched. */
+  case Constant(text: String)
+
+  /** The span is replaced by `f(matched)` -- the fix depends on what it matched.
+    *
+    * `quoted-constant-literal` is the reason this exists: `constant N: Integer = "5"` becomes `5`,
+    * and the replacement is the matched text minus its quotes. That is a pure span replacement --
+    * it just is not a constant one, and it was excluded from `--fix` purely for want of a way to
+    * say so.
+    */
+  case Computed(f: String => String)
+
+  /** The replacement for a given matched span. */
+  def apply(matched: String): String = this match
+    case Constant(text) => text
+    case Computed(f)    => f(matched)
+
+  /** The constant text, when there is one. What the published `Map[String, String]` can carry. */
+  def constantText: Option[String] = this match
+    case Constant(text) => Some(text)
+    case _: Computed    => None
+end Fix
+
 enum RuleId(
   val code: String,
-  val mechanicalFix: Option[String] = None,
+  val mechanicalFix: Option[Fix] = None,
   val deprecates: Boolean = false
 ):
 
@@ -154,17 +190,25 @@ enum RuleId(
   // was renamed to DoStatement in 2026-08-25 while its code deliberately was not. Renaming a rule
   // is a source change; renaming its code is an API break.
   case StateIsRecord extends RuleId("state-is-record", deprecates = true)
-  case DoStatement extends RuleId("prompt-statement", mechanicalFix = Some("do"), deprecates = true)
+  case DoStatement extends RuleId("prompt-statement", mechanicalFix = Some(Fix.Constant("do")), deprecates = true)
   case SendToInlet extends RuleId("send-to-inlet", deprecates = true)
   case BareStringCondition extends RuleId("bare-string-condition", deprecates = true)
   case AnonymousNebula extends RuleId("anonymous-nebula", deprecates = true)
   case ShapeKeyword extends RuleId("shape-keyword", deprecates = true)
-  case AbstractType extends RuleId("abstract-type", mechanicalFix = Some("Anything"), deprecates = true)
+  case AbstractType extends RuleId("abstract-type", mechanicalFix = Some(Fix.Constant("Anything")), deprecates = true)
   case SingleAlternation extends RuleId("single-alternation", deprecates = true)
   case EntityOptionToIntention extends RuleId("entity-option-to-intention", deprecates = true)
   case TypeFirstAggregate extends RuleId("type-first-aggregate", deprecates = true)
   case ConnectorOptionToIntention extends RuleId("connector-option-to-intention", deprecates = true)
-  case QuotedConstantLiteral extends RuleId("quoted-constant-literal", deprecates = true)
+  // The fix is the matched text minus its surrounding quotes -- `"5"` becomes `5`. A pure span
+  // replacement that simply is not a CONSTANT one, which is the only reason it was excluded from
+  // `--fix` until [1.16].
+  case QuotedConstantLiteral
+      extends RuleId(
+        "quoted-constant-literal",
+        mechanicalFix = Some(Fix.Computed(m => m.stripPrefix("\"").stripSuffix("\""))),
+        deprecates = true
+      )
 
   // ---- handler: handlers and their on-clauses ----------------------------------------------
   case HandlerNoExecutableStatements extends RuleId("handler-no-executable-statements")
@@ -583,7 +627,18 @@ object RuleId:
   lazy val deprecations: Seq[RuleId] = values.filter(_.deprecates).toSeq
 
   /** Every rule whose fix is a pure span replacement, as code -> replacement text. */
+  /** Rules whose fix is a CONSTANT replacement, as code -> text.
+    *
+    * A computed fix cannot appear here -- its replacement depends on the matched text, which a
+    * `Map[String, String]` has no way to express. Omitting it is the honest answer: a consumer
+    * reading this map gets replacements it can apply blindly, and `validate --fix` (which has the
+    * matched span) applies the computed ones itself.
+    */
   lazy val mechanicalReplacements: Map[String, String] =
+    values.flatMap(r => r.mechanicalFix.flatMap(_.constantText).map(r.code -> _)).toMap
+
+  /** Every rule with any mechanical fix, constant or computed. What `validate --fix` acts on. */
+  lazy val fixable: Map[String, Fix] =
     values.flatMap(r => r.mechanicalFix.map(r.code -> _)).toMap
 
   /** The subject prefix -- the part before the first `-`. Lets a consumer select a whole family. */

language/src/test/scala/com/ossuminc/riddl/language/LoggerIdentityTest.scala

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2019-2026 Ossum Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package com.ossuminc.riddl.language
+
+import com.ossuminc.riddl.utils.{AbstractTestingBasis, pc}
+
+/** [1.18]: `pc.log` must return the SAME logger each call, on every platform.
+  *
+  * `DOMPlatformContext` overrode `def log` to return a fresh `SysLogger()` per call. That defeated
+  * `withLogger` — the visible symptom — but it also silently zeroed the per-instance message
+  * counters `Logger.summary` reports, because every `count()` landed on a different instance. The
+  * second casualty was invisible until the first was diagnosed.
+  *
+  * SHARED on purpose: the defect was a platform difference, so a suite that skips the platform it
+  * differs on cannot see it return.
+  */
+class LoggerIdentityTest extends AbstractTestingBasis {
+
+  "pc.log" should {
+
+    "return the same instance across calls, so state survives" in {
+      // Reference identity is the whole assertion: a fresh logger per call is precisely the bug.
+      assert(pc.log eq pc.log, "pc.log returned a different Logger on a second call")
+    }
+
+    "accumulate message counts rather than losing them" in {
+      val before = pc.log.summary
+      pc.log.error("one")
+      pc.log.error("two")
+      val after = pc.log.summary
+      // Counting into a discarded instance leaves the summary unchanged, which is what happened
+      // on JS for as long as the override stood.
+      assert(before != after, s"summary did not change after logging:\n$after")
+    }
+  }
+}

…dl/language/RuleIdLogRenderingTest.scala …dl/language/RuleIdLogRenderingTest.scalalanguage/src/test/scala-jvm-native/com/ossuminc/riddl/language/RuleIdLogRenderingTest.scala renamed to language/src/test/scala/com/ossuminc/riddl/language/RuleIdLogRenderingTest.scala language/src/test/scala-jvm-native/com/ossuminc/riddl/language/RuleIdLogRenderingTest.scala renamed to language/src/test/scala/com/ossuminc/riddl/language/RuleIdLogRenderingTest.scala

@@ -10,12 +10,15 @@ import com.ossuminc.riddl.utils.{AbstractTestingBasis, CallBackLogger, pc}
 
 /** The rule id is rendered by the LOGGER, beside the kind prefix it already supplies.
   *
-  * **This suite is `scala-jvm-native` because `withLogger` cannot capture on Scala.js.**
-  * `DOMPlatformContext` overrides `def log` to return a fresh `SysLogger()` on every call
-  * (`DOMPlatformContext.scala:88`), so the logger `withLogger` swaps into the `logger` field is
-  * never consulted and a capture reads the empty string. The rendering itself is fine on JS -- CI
-  * printed `[error] [field-duplicate-name] ...` in the very run where this assertion failed, which
-  * is the tell that the INSTRUMENT was broken and not the feature. Filed as BACKLOG [1.18].
+  * **This suite is SHARED again as of [1.18].** It lived in `scala-jvm-native` for a day because
+  * `withLogger` could not capture on Scala.js: `DOMPlatformContext` overrode `def log` to return a
+  * FRESH `SysLogger()` on every call, so the logger `withLogger` swapped into the `logger` field
+  * was never consulted. The override also silently zeroed every per-instance message counter, and
+  * it returned exactly what the base field is already initialised to -- so deleting it restored
+  * `withLogger` and the counters while changing nothing about default behaviour.
+  *
+  * Running here on all three rows is the point: the defect was a PLATFORM difference, and a suite
+  * that skips the platform it differs on cannot see it come back.
   *
   * The platform-independent half -- that the id stays OUT of `Message.format`, where
   * `CheckMessagesTest` compares its goldens -- is asserted in the shared `RuleIdTest`.

riddlLib/src/main/scala/com/ossuminc/riddl/RiddlLib.scala

@@ -971,8 +971,13 @@ object RiddlLib extends RiddlLib:
         // carries its own mechanical replacement cannot fall out of step with one.
         val edits = msgs.justDeprecations.toSeq.flatMap { m =>
           m.ruleId.flatMap(rule => rule.mechanicalFix.map(rule.code -> _)).map {
-            case (code, replacement) =>
-              SourceEdit(m.loc.offset, m.loc.endOffset, replacement, code, origin)
+            case (code, fix) =>
+              // A COMPUTED fix needs the text it matched, and this function has the source -- so it
+              // slices the span rather than dropping the fix. `quoted-constant-literal` (`"5"` ->
+              // `5`) is only expressible this way, which is why [1.16] made `Fix` a sum type
+              // instead of widening the published `Map[String, String]` that cannot carry it.
+              val matched = source.slice(m.loc.offset, m.loc.endOffset)
+              SourceEdit(m.loc.offset, m.loc.endOffset, fix(matched), code, origin)
           }
         }
         // Descending, so applying them in order never shifts an offset still to be used.

utils/src/main/scalajs/com/ossuminc/riddl/utils/DOMPlatformContext.scala

@@ -85,8 +85,6 @@ case class DOMPlatformContext() extends PlatformContext {
 
   override def stderrln(message: String): Unit = dom.console.error(message + newline)
 
-  override def log: Logger = SysLogger()
-
   override def newline: String = "\n"
 
   override def ec: ExecutionContext = scala.concurrent.ExecutionContext.global