Quote special-character identifiers in Identifier.format and prettify

RIDDL identifiers may be single-quoted to carry special characters
(spaces, /, @, etc.), and the parser accepts that form. The prettifier
emitted them unquoted, so parse -> prettify -> parse was not a round-trip
for such names (e.g. a user named 'CI/CD Pipeline').

- Identifier.format now single-quotes non-bare names. Adds public
  Identifier.isBareIdentifier(String) and Identifier.format(String),
  matching CommonParser.simpleIdentifier ([A-Za-z][A-Za-z0-9_-]*) and the
  EBNF simple_identifier rule exactly. Hyphens are bare (correcting the
  original proposal); empty stays empty.
- PathIdentifier.format wraps a whole path in one pair of quotes when any
  component is special ('a.CI/CD Pipeline.c') rather than quoting each
  component.
- Parser: pathIdentifier gains a whole-path quoted form
  (dottedPathIdentifier | quotedPathIdentifier); the dotted form is tried
  first so existing inputs (including per-component a.'x'.b) parse
  unchanged. EBNF grammar updated and GBNF regenerated; both the TatSu
  EBNF validator and the GBNF validator pass.
- Prettifier: five emit sites that rendered names via raw .id.value
  (including user names -- the reported repro) now go through .id.format.
- Display: format() is also used by identify() and error-message
  templates, which supply their own quotes. The two identify methods plus
  13 direct templates now use the raw value/path inside those quotes, so
  special and synthetic names (e.g. OnMessageClause 'command DooFoo') are
  not double-quoted. Restores exact pre-change message output.

Tests: ASTTest covers Identifier.format (bare, hyphen, special,
digit-leading, full quoted charset, empty), isBareIdentifier, and
PathIdentifier whole-path quoting; new IdentifierQuotingRoundTripTest
covers parse -> prettify -> parse fidelity for a special-char user, type,
and path reference. Green on JVM and Native; JS compiles.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: reid-spencer

language/shared/src/main/resources/riddl/grammar/ebnf-grammar.ebnf

@@ -15,7 +15,9 @@ any_char_except_triple_backtick = /(?:[^`]|`(?!``)|``(?!`))+/ ;
 identifier = simple_identifier | quoted_identifier ;
 simple_identifier = /[A-Za-z][A-Za-z0-9_-]*/ ;
 quoted_identifier = /'[-A-Za-z0-9_+\\|\/@$%&,: ]+'/ ;
-path_identifier = identifier { "." identifier } ;
+path_identifier = dotted_path_identifier | quoted_path_identifier ;
+dotted_path_identifier = identifier { "." identifier } ;
+quoted_path_identifier = /'[-A-Za-z0-9_+\\|\/@$%&,: .]+'/ ;
 literal_string = '"' { string_char | escape_sequence } '"' ;
 escape_sequence = /\\[\\\"aefnrt]/ | hexEscape | unicodeEscape ;
 hexEscape = /\\x[0-9a-fA-F]{2,8}/ ;

language/shared/src/main/resources/riddl/grammar/riddl-grammar.gbnf

@@ -2,7 +2,7 @@
 # (llama.cpp constrained generation)
 # AUTO-GENERATED from ebnf-grammar.ebnf by ebnf_to_gbnf.py
 # DO NOT EDIT - modify the source EBNF or gbnf_overrides.gbnf instead
-# Generated: 2026-06-25 00:35 UTC
+# Generated: 2026-07-10 19:08 UTC
 
 # Whitespace primitives
 ws ::= [ \t\n\r]*
@@ -24,7 +24,9 @@ any-char-except-triple-backtick ::= ([^`] | "`" [^`] | "``" [^`])+  # (from over
 identifier ::= simple-identifier | quoted-identifier
 simple-identifier ::= [A-Za-z] [A-Za-z0-9_-]*
 quoted-identifier ::= "'" [-A-Za-z0-9_+\\|/@$%&,: ]+ "'"
-path-identifier ::= identifier ("." identifier)*
+path-identifier ::= dotted-path-identifier | quoted-path-identifier
+dotted-path-identifier ::= identifier ws ("." identifier)*
+quoted-path-identifier ::= "'" ws [-A-Za-z0-9_+\\|/@$%&,: .]+ ws "'"
 literal-string ::= "\"" (string-char | escape-sequence)* "\""
 escape-sequence ::= "\\" [\\"aefnrt] | hex-escape | unicode-escape
 hex-escape ::= "\\x" [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F]? [0-9a-fA-F]? [0-9a-fA-F]? [0-9a-fA-F]? [0-9a-fA-F]? [0-9a-fA-F]?

language/shared/src/main/scala/com/ossuminc/riddl/language/AST.scala

@@ -161,14 +161,45 @@ object AST:
     *   The parsed value of the [[Identifier]]
     */
   case class Identifier(loc: At, value: String) extends RiddlValue:
-    override def format: String = value
+    override def format: String = Identifier.format(value)
     override def isEmpty: Boolean = value.isEmpty
   end Identifier
 
   /** Companion object for the Identifier class to provide the empty value */
   object Identifier:
     /** Definition of the empty [[Identifier]] */
     val empty: Identifier = Identifier(At.empty, "")
+
+    private def isAsciiLetter(c: Char): Boolean =
+      (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
+
+    /** A character permitted after the first in a bare identifier. Kept in
+      * sync with `CommonParser.simpleIdentifier`
+      * (`[A-Za-z][A-Za-z0-9_\-]*`) and the EBNF `simple_identifier` rule.
+      */
+    private def isBareIdChar(c: Char): Boolean =
+      isAsciiLetter(c) || (c >= '0' && c <= '9') || c == '_' || c == '-'
+
+    /** True when `value` is a bare (unquoted) identifier and therefore can be
+      * emitted to RIDDL source verbatim. Matches the parser's
+      * `simpleIdentifier` rule exactly: an ASCII letter followed by any number
+      * of ASCII letters, digits, underscores, or hyphens.
+      */
+    def isBareIdentifier(value: String): Boolean =
+      value.nonEmpty && isAsciiLetter(value.head) && value.tail.forall(isBareIdChar)
+
+    /** Render an identifier `value` as valid RIDDL source. A bare identifier is
+      * emitted unchanged; anything else is single-quoted using the parser's
+      * `quotedIdentifier` form (`'...'`). An empty value is preserved as empty.
+      *
+      * Note: RIDDL's quoted-identifier syntax has no escape for a single quote
+      * and only admits `[A-Za-z0-9_+\-|/@$%&, :]`; a value outside that set
+      * (e.g. containing `.` or `'`) cannot be represented in RIDDL at all, but
+      * such values never arise from parsing (only from in-memory / JSON
+      * construction). Quoting is the best available rendering.
+      */
+    def format(value: String): String =
+      if value.isEmpty || isBareIdentifier(value) then value else s"'$value'"
   end Identifier
 
   /** Represents a segmented identifier to a definition in the model. Path Identifiers are parsed
@@ -181,7 +212,15 @@ object AST:
     *   The list of strings that make up the path identifier
     */
   case class PathIdentifier(loc: At, value: Seq[String]) extends RiddlValue:
-    override def format: String = value.mkString(".")
+    /** Render the path to RIDDL source. When every component is bare (or
+      * empty), emit the plain dotted form `a.b.c`. When any component carries
+      * special characters, wrap the whole dotted path in a single pair of
+      * quotes — `'a.CI/CD Pipeline.c'` — using the parser's quoted-path form,
+      * rather than quoting each component individually.
+      */
+    override def format: String =
+      if value.forall(p => p.isEmpty || Identifier.isBareIdentifier(p)) then value.mkString(".")
+      else s"'${value.mkString(".")}'"
     override def isEmpty: Boolean = value.isEmpty || value.forall(_.isEmpty)
   end PathIdentifier
 
@@ -352,11 +391,13 @@ object AST:
       *   String A string that describes this reference
       */
     def identify: String =
+      // Human-readable display: supply our own quotes around the raw path, so
+      // special-character names are not double-quoted by Identifier.format.
       s"${classTag[T].runtimeClass.getSimpleName} ${
           if id.nonEmpty then {
-            id.map(_.format + ": ")
+            id.map(_.value + ": ")
           } else ""
-        }'${pathId.format}'"
+        }'${pathId.value.mkString(".")}'"
     end identify
 
     override def isEmpty: Boolean = pathId.isEmpty
@@ -385,7 +426,9 @@ object AST:
       if id.isEmpty then {
         s"Anonymous $kind"
       } else {
-        s"$kind '${id.format}'"
+        // Display supplies its own quotes; use the raw value so that
+        // special-character names are not double-quoted by Identifier.format.
+        s"$kind '${id.value}'"
       }
     end identify
 

language/shared/src/main/scala/com/ossuminc/riddl/language/parsing/CommonParser.scala

@@ -208,10 +208,29 @@ private[parsing] trait CommonParser(using pc: PlatformContext)
     }
   }
 
+  private def dottedPathIdentifier[u: P]: P[Seq[String]] = {
+    P(anyIdentifier ~~ (Punctuation.dot ~~ anyIdentifier).repX(0)).map { case (first, strings) =>
+      first +: strings
+    }
+  }
+
+  /** A whole path wrapped in a single pair of quotes with `.` separating the
+    * components, e.g. `'a.CI/CD Pipeline.c'`. This lets an emitter quote a path
+    * containing special-character components without quoting each component.
+    * The character class is `quotedIdentifier`'s set plus `.`.
+    */
+  private def quotedPathIdentifier[u: P]: P[Seq[String]] = {
+    P("'" ~~ CharsWhileIn("a-zA-Z0-9_+\\-|/@$%&, :.", 1).! ~~ "'").map { s =>
+      s.split('.').toIndexedSeq
+    }
+  }
+
   def pathIdentifier[u: P]: P[PathIdentifier] = {
-    P(Index ~ anyIdentifier ~~ (Punctuation.dot ~~ anyIdentifier).repX(0) ~~ Index).map {
-      case (off1, first, strings, off2) =>
-        PathIdentifier(at(off1, off2), first +: strings)
+    // Try the dotted form first so existing inputs (including per-component
+    // quoted parts like `a.'x'.b`) parse unchanged; fall back to the
+    // whole-path quoted form only when a `.` appears inside the quotes.
+    P(Index ~ (dottedPathIdentifier | quotedPathIdentifier) ~~ Index).map { case (off1, parts, off2) =>
+      PathIdentifier(at(off1, off2), parts)
     }
   }
 

language/shared/src/test/scala/com/ossuminc/riddl/language/ASTTest.scala

@@ -33,6 +33,50 @@ class ASTTest extends AbstractTestingBasis {
     }
   }
 
+  "Identifier" should {
+    "emit bare names verbatim" in {
+      Identifier(At.empty, "Order").format mustBe "Order"
+      Identifier(At.empty, "Order_2").format mustBe "Order_2"
+    }
+    "treat hyphenated names as bare (matching the parser's rule)" in {
+      // simpleIdentifier is [A-Za-z][A-Za-z0-9_-]* — hyphens are allowed
+      Identifier(At.empty, "my-entity").format mustBe "my-entity"
+    }
+    "quote names with special characters" in {
+      Identifier(At.empty, "CI/CD Pipeline").format mustBe "'CI/CD Pipeline'"
+      Identifier(At.empty, "Order Item").format mustBe "'Order Item'"
+    }
+    "quote names that start with a digit" in {
+      Identifier(At.empty, "3dModel").format mustBe "'3dModel'"
+    }
+    "quote every character the quoted-identifier form allows" in {
+      Identifier(At.empty, "a+b-c|d/e@f$g%h&i,j:k").format mustBe "'a+b-c|d/e@f$g%h&i,j:k'"
+    }
+    "preserve an empty value" in {
+      Identifier(At.empty, "").format mustBe ""
+    }
+    "expose isBareIdentifier that agrees with simpleIdentifier" in {
+      Identifier.isBareIdentifier("Order") mustBe true
+      Identifier.isBareIdentifier("my-entity") mustBe true
+      Identifier.isBareIdentifier("A1_b-2") mustBe true
+      Identifier.isBareIdentifier("3d") mustBe false // starts with a digit
+      Identifier.isBareIdentifier("_x") mustBe false // must start with a letter
+      Identifier.isBareIdentifier("CI/CD") mustBe false
+      Identifier.isBareIdentifier("") mustBe false
+    }
+  }
+
+  "PathIdentifier quoting" should {
+    "emit an all-bare path as a plain dotted form" in {
+      PathIdentifier(At.empty, Seq("A", "B", "C")).format mustBe "A.B.C"
+      PathIdentifier(At.empty, Seq("my-ctx", "my-entity")).format mustBe "my-ctx.my-entity"
+    }
+    "wrap the whole path in one pair of quotes when a component is special" in {
+      PathIdentifier(At.empty, Seq("A", "CI/CD Pipeline", "C")).format mustBe "'A.CI/CD Pipeline.C'"
+      PathIdentifier(At.empty, Seq("CI/CD Pipeline")).format mustBe "'CI/CD Pipeline'"
+    }
+  }
+
   "Types" should {
     "support domain definitions" in {
       Domain((0, 0), Identifier((1, 1), "foo")) must be

passes/jvm-native/src/test/scala/com/ossuminc/riddl/passes/prettify/IdentifierQuotingRoundTripTest.scala

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2019-2026 Ossum Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package com.ossuminc.riddl.passes.prettify
+
+import com.ossuminc.riddl.language.AST.*
+import com.ossuminc.riddl.language.Finder
+import com.ossuminc.riddl.language.parsing.{RiddlParserInput, TopLevelParser}
+import com.ossuminc.riddl.passes.validate.AbstractValidatingTest
+import com.ossuminc.riddl.passes.{Pass, PassInput, PassesOutput}
+import com.ossuminc.riddl.utils.pc
+
+import org.scalatest.*
+
+/** Verifies that special-character identifiers survive a
+  * parse -> prettify -> parse round-trip now that `Identifier.format` /
+  * `PathIdentifier.format` single-quote non-bare names.
+  */
+class IdentifierQuotingRoundTripTest extends AbstractValidatingTest {
+
+  private def parse(src: String, origin: String): Root =
+    TopLevelParser.parseInput(RiddlParserInput(src, origin)) match
+      case Right(root) => root
+      case Left(msgs)  => fail(s"parse of $origin failed:\n${msgs.format}")
+
+  /** Run the prettifier (flatten) over a Root and return the rendered source. */
+  private def prettify(root: Root): String =
+    val creators = Pass.standardPasses :+ { (in: PassInput, out: PassesOutput) =>
+      PrettifyPass(in, out, PrettifyPass.Options(flatten = true, inputDir = ""))
+    }
+    val result = Pass.runThesePasses(PassInput(root), creators)
+    result.outputs
+      .outputOf[PrettifyOutput](PrettifyPass.name)
+      .getOrElse(fail("PrettifyPass produced no output"))
+      .state
+      .filesAsString
+
+  "Identifier quoting" should {
+
+    "round-trip a user whose name has special characters (the repro)" in {
+      (td: TestData) =>
+        val src = """domain D is { user 'CI/CD Pipeline' is "an operator" }"""
+        val root1 = parse(src, "src")
+        Finder(root1).recursiveFindByType[User].head.id.value mustBe "CI/CD Pipeline"
+
+        val pretty = prettify(root1)
+        pretty must include("user 'CI/CD Pipeline'")
+
+        // The prettified output must re-parse to the same identifier value.
+        val root2 = parse(pretty, "regen")
+        Finder(root2).recursiveFindByType[User].head.id.value mustBe "CI/CD Pipeline"
+    }
+
+    "round-trip a type whose name has special characters" in { (td: TestData) =>
+      val src = """domain D is { type 'CI/CD Pipeline' is String }"""
+      val pretty = prettify(parse(src, "src"))
+      pretty must include("type 'CI/CD Pipeline' is")
+      val types = Finder(parse(pretty, "regen")).recursiveFindByType[Type]
+      types.map(_.id.value) must contain("CI/CD Pipeline")
+    }
+
+    "round-trip a path reference with a special-character component" in {
+      (td: TestData) =>
+        // A path whose middle component has a space: emitted as one quoted
+        // whole path 'D.Weird Name', parsed back to the same components.
+        val src =
+          """domain D is {
+            |  type 'Weird Name' is String
+            |  type Alias is 'D.Weird Name'
+            |}
+            |""".stripMargin
+        def aliasPath(root: Root): Seq[String] =
+          Finder(root).recursiveFindByType[Type].find(_.id.value == "Alias").get.typEx match
+            case ate: AliasedTypeExpression => ate.pathId.value
+            case other                      => fail(s"expected AliasedTypeExpression, got $other")
+
+        val root1 = parse(src, "src")
+        aliasPath(root1) mustBe Seq("D", "Weird Name")
+
+        val pretty = prettify(root1)
+        pretty must include("'D.Weird Name'")
+
+        aliasPath(parse(pretty, "regen")) mustBe Seq("D", "Weird Name")
+    }
+  }
+}

passes/shared/src/main/scala/com/ossuminc/riddl/passes/prettify/PrettifyVisitor.scala

@@ -271,7 +271,7 @@ class PrettifyVisitor(options: PrettifyPass.Options)(using PlatformContext) exte
   def doUser(user: User): Unit =
     state.withCurrent { rfe =>
       rfe
-        .addIndent(s"user ${user.id.value} is \"${user.is_a.s}\"")
+        .addIndent(s"user ${user.id.format} is \"${user.is_a.s}\"")
         .emitMetaData(user.metadata)
     }
   end doUser

passes/shared/src/main/scala/com/ossuminc/riddl/passes/prettify/RiddlFileEmitter.scala

@@ -162,7 +162,7 @@ case class RiddlFileEmitter(url: URL)(using PlatformContext) extends FileBuilder
     add(s"any of {").nl.incr
     val enumerators: String = enumeration.enumerators.toSeq
       .map { enumerator =>
-        enumerator.id.value + enumerator.enumVal.fold("")(x => s"($x)")
+        enumerator.id.format + enumerator.enumVal.fold("")(x => s"($x)")
       }
       .mkString(s"$spc", s",$new_line$spc", new_line)
     add(enumerators).decr.addLine("}")
@@ -179,14 +179,14 @@ case class RiddlFileEmitter(url: URL)(using PlatformContext) extends FileBuilder
   }
 
   def emitField(field: Field): this.type =
-    add(s"${field.id.value}: ")
+    add(s"${field.id.format}: ")
     emitTypeExpression(field.typeEx)
     emitMetaData(field.metadata)
     this
   end emitField
 
   def emitMethod(method: Method): this.type =
-    add(s"${method.id.value}(${method.args.map(_.format).mkString(", ")}): ")
+    add(s"${method.id.format}(${method.args.map(_.format).mkString(", ")}): ")
     emitTypeExpression(method.typeEx)
     emitMetaData(method.metadata)
     this
@@ -308,7 +308,7 @@ case class RiddlFileEmitter(url: URL)(using PlatformContext) extends FileBuilder
   }
 
   def emitType(t: Type): this.type = {
-    add(s"${spc}type ${t.id.value} is ")
+    add(s"${spc}type ${t.id.format} is ")
     emitTypeExpression(t.typEx)
     emitMetaData(t.metadata)
     this

passes/shared/src/main/scala/com/ossuminc/riddl/passes/resolve/ReferenceMap.scala

@@ -91,8 +91,8 @@ case class ReferenceMap(messages: Messages.Accumulator) {
         val className = classTag[T].runtimeClass.getSimpleName
         messages.addError(
           pid.loc,
-          s"Path Id '${pid.format} found ${x.identify} but a $className was expected",
-          suggestion = s"Point '${pid.format}' at a $className, or rename the reference to match the intended $className."
+          s"Path Id '${pid.value.mkString(".")} found ${x.identify} but a $className was expected",
+          suggestion = s"Point '${pid.value.mkString(".")}' at a $className, or rename the reference to match the intended $className."
         )
         None
   }