Improved-scala3-enums

.github/workflows/test-pr.yaml

@@ -53,6 +53,7 @@ jobs:
                     - ruby
                     - php,schema-php
                     - scala3,schema-scala3
+                    - scala3-upickle,schema-scala3-upickle
                     - elixir,schema-elixir,graphql-elixir
                     - comment-injection-treesitter,comment-injection-typescript,comment-injection-typescript-zod,comment-injection-typescript-effect-schema
 

packages/quicktype-core/src/language/Scala3/CirceRenderer.ts

@@ -14,8 +14,10 @@ import type {
     UnionType,
 } from "../../Type/index.js";
 
+import { stringEscape } from "../../support/Strings.js";
+
 import { Scala3Renderer } from "./Scala3Renderer.js";
-import { wrapOption } from "./utils.js";
+import { unionMemberSortOrder, wrapOption } from "./utils.js";
 
 export class CirceRenderer extends Scala3Renderer {
     private readonly seenUnionTypes: string[] = [];
@@ -55,7 +57,13 @@ export class CirceRenderer extends Scala3Renderer {
                 paramName,
                 ")",
             ],
-            (_) => ["Encoder.encodeString(", paramName, ")"],
+            (enumType) => [
+                "summon[Encoder[",
+                this.scalaType(enumType),
+                "]].apply(",
+                paramName,
+                ")",
+            ],
             (unionType) => {
                 const nullable = nullableFromUnion(unionType);
                 if (nullable !== null) {
@@ -103,44 +111,70 @@ export class CirceRenderer extends Scala3Renderer {
 
     protected emitEnumDefinition(e: EnumType, enumName: Name): void {
         this.emitDescription(this.descriptionForType(e));
+        this.ensureBlankLine();
 
+        // Enum cases are styled Scala identifiers; the codecs below map
+        // them back to the original JSON strings, which can be anything
+        // (keywords, `"_"`, `""`, …).
+        this.emitLine(["enum ", enumName, " : "]);
+        this.indent(() => {
+            this.forEachEnumCase(e, "none", (name) => {
+                this.emitLine("case ", name);
+            });
+        });
         this.ensureBlankLine();
-        this.emitItem(["type ", enumName, " = "]);
-        let count = e.cases.size;
-        this.forEachEnumCase(e, "none", (_, jsonName) => {
-            // if (!(jsonName == "")) {
-            /*                 const backticks = 
-															shouldAddBacktick(jsonName) || 
-															jsonName.includes(" ") || 
-															!isNaN(parseInt(jsonName.charAt(0)))
-													if (backticks) {this.emitItem("`")} else  */
-            this.emitItem(['"', jsonName, '"']);
-            //                if (backticks) {this.emitItem("`")}
-            if (--count > 0) this.emitItem([" | "]);
-            // } else {
-            // --count
-            // }
+
+        this.emitLine([
+            "given Decoder[",
+            enumName,
+            "] = Decoder.decodeString.emap {",
+        ]);
+        this.indent(() => {
+            // `scala.` in case a generated type is named Right/Left.
+            this.forEachEnumCase(e, "none", (name, jsonName) => {
+                this.emitLine([
+                    `case "${stringEscape(jsonName)}" => scala.Right(`,
+                    enumName,
+                    ".",
+                    name,
+                    ")",
+                ]);
+            });
+            this.emitLine([
+                'case other => scala.Left("invalid ',
+                enumName,
+                ': " + other)',
+            ]);
         });
+        this.emitLine("}");
+        this.emitLine([
+            "given Encoder[",
+            enumName,
+            "] = Encoder.encodeString.contramap {",
+        ]);
+        this.indent(() => {
+            this.forEachEnumCase(e, "none", (name, jsonName) => {
+                this.emitLine([
+                    "case ",
+                    enumName,
+                    ".",
+                    name,
+                    ` => "${stringEscape(jsonName)}"`,
+                ]);
+            });
+        });
+        this.emitLine("}");
         this.ensureBlankLine();
     }
 
     protected emitHeader(): void {
         super.emitHeader();
 
-        this.emitLine("import scala.util.Try");
         this.emitLine("import io.circe.syntax._");
         this.emitLine("import io.circe._");
         this.emitLine("import cats.syntax.functor._");
         this.ensureBlankLine();
 
-        this.emitLine("// For serialising string unions");
-        this.emitLine(
-            "given [A <: Singleton](using A <:< String): Decoder[A] = Decoder.decodeString.emapTry(x => Try(x.asInstanceOf[A])) ",
-        );
-        this.emitLine(
-            "given [A <: Singleton](using ev: A <:< String): Encoder[A] = Encoder.encodeString.contramap(ev) ",
-        );
-        this.ensureBlankLine();
         this.emitLine(
             "// If a union has a null in, then we'll need this too... ",
         );
@@ -153,9 +187,9 @@ export class CirceRenderer extends Scala3Renderer {
         this.emitLine([
             "given (using ev : ",
             elementType,
-            "): Encoder[Map[String,",
+            "): Encoder[Seq[",
             elementType,
-            "]] = Encoder.encodeMap[String, ",
+            "]] = Encoder.encodeSeq[",
             elementType,
             "]",
         ]);
@@ -177,15 +211,9 @@ export class CirceRenderer extends Scala3Renderer {
     }
 
     protected emitUnionDefinition(u: UnionType, unionName: Name): void {
-        function sortBy(t: Type): string {
-            const kind = t.kind;
-            if (kind === "class") return kind;
-            return `_${kind}`;
-        }
-
         this.emitDescription(this.descriptionForType(u));
 
-        const [maybeNull, nonNulls] = removeNullFromUnion(u, sortBy);
+        const [maybeNull, nonNulls] = removeNullFromUnion(u, false);
         const theTypes: Sourcelike[] = [];
         this.forEachUnionMember(u, nonNulls, "none", null, (_, t) => {
             theTypes.push(this.scalaType(t));
@@ -205,10 +233,20 @@ export class CirceRenderer extends Scala3Renderer {
         this.ensureBlankLine();
         if (!this.seenUnionTypes.some((y) => y === thisUnionType)) {
             this.seenUnionTypes.push(thisUnionType);
+            // The decoders are tried in order, most discriminating
+            // first (see `unionMemberSortOrder`): circe's numeric
+            // decoders accept strings like "5", so the string decoder
+            // has to get a shot before them.
             const sourceLikeTypes: Array<[Sourcelike, Type]> = [];
-            this.forEachUnionMember(u, nonNulls, "none", null, (_, t) => {
-                sourceLikeTypes.push([this.scalaType(t), t]);
-            });
+            this.forEachUnionMember(
+                u,
+                nonNulls,
+                "none",
+                unionMemberSortOrder,
+                (_, t) => {
+                    sourceLikeTypes.push([this.scalaType(t), t]);
+                },
+            );
             if (maybeNull !== null) {
                 sourceLikeTypes.push([
                     this.nameForUnionMember(u, maybeNull),

packages/quicktype-core/src/language/Scala3/Scala3Renderer.ts

@@ -30,9 +30,10 @@ import {
 import { keywords } from "./constants.js";
 import type { scala3Options } from "./language.js";
 import {
+    backtickedName,
+    enumCaseNameStyle,
     lowerNamingFunction,
     scalaNameStyle,
-    shouldAddBacktick,
     upperNamingFunction,
     wrapOption,
 } from "./utils.js";
@@ -61,7 +62,7 @@ export class Scala3Renderer extends ConvenienceRenderer {
         _: EnumType,
         _enumName: Name,
     ): ForbiddenWordsInfo {
-        return { names: [], includeGlobalForbidden: true };
+        return { names: ["_"], includeGlobalForbidden: true };
     }
 
     protected forbiddenForUnionMembers(
@@ -91,7 +92,7 @@ export class Scala3Renderer extends ConvenienceRenderer {
     }
 
     protected makeEnumCaseNamer(): Namer {
-        return funPrefixNamer("upper", (s) => s.replace(" ", "")); // TODO - add backticks where appropriate
+        return funPrefixNamer("upper", enumCaseNameStyle);
     }
 
     protected emitDescriptionBlock(lines: Sourcelike[]): void {
@@ -262,14 +263,9 @@ export class Scala3Renderer extends ConvenienceRenderer {
                     emit();
                 }
 
-                const nameNeedsBackticks =
-                    jsonName.endsWith("_") || shouldAddBacktick(jsonName);
-                const nameWithBackticks = nameNeedsBackticks
-                    ? `\`${jsonName}\``
-                    : jsonName;
                 this.emitLine(
                     "val ",
-                    nameWithBackticks,
+                    backtickedName(jsonName),
                     " : ",
                     scalaType(p),
                     p.isOptional
@@ -301,32 +297,8 @@ export class Scala3Renderer extends ConvenienceRenderer {
         this.emitBlock(
             ["enum ", enumName, " : "],
             () => {
-                let count = e.cases.size;
-                if (count > 0) {
-                    this.emitItem("\t case ");
-                }
-
-                this.forEachEnumCase(e, "none", (name, jsonName) => {
-                    if (!(jsonName === "")) {
-                        const backticks =
-                            shouldAddBacktick(jsonName) ||
-                            jsonName.includes(" ") ||
-                            !Number.isNaN(
-                                Number.parseInt(jsonName.charAt(0), 10),
-                            );
-                        if (backticks) {
-                            this.emitItem("`");
-                        }
-
-                        this.emitItemOnce([name]);
-                        if (backticks) {
-                            this.emitItem("`");
-                        }
-
-                        if (--count > 0) this.emitItem([","]);
-                    } else {
-                        --count;
-                    }
+                this.forEachEnumCase(e, "none", (name) => {
+                    this.emitLine("case ", name);
                 });
             },
             "none",
@@ -361,12 +333,14 @@ export class Scala3Renderer extends ConvenienceRenderer {
     protected emitSourceStructure(): void {
         this.emitHeader();
 
-        // Top-level arrays, maps
+        // Top-level arrays, maps, and primitives
         this.forEachTopLevel("leading", (t, name) => {
             if (t instanceof ArrayType) {
                 this.emitTopLevelArray(t, name);
             } else if (t instanceof MapType) {
                 this.emitTopLevelMap(t, name);
+            } else if (t.isPrimitive()) {
+                this.emitLine(["type ", name, " = ", this.scalaType(t)]);
             }
         });