[pull] master from glideapps:master

packages/quicktype-core/src/input/JSONSchemaInput.ts

@@ -1084,14 +1084,17 @@ async function addTypesInSchema(
                     emptyTypeAttributes,
                     new Set(itemTypes),
                 );
-            } else if (typeof items === "object") {
+            } else if (
+                typeof items === "object" ||
+                typeof items === "boolean"
+            ) {
                 const itemsLoc = loc.push("items");
                 itemType = await toType(
                     checkJSONSchema(items, itemsLoc.canonicalRef),
                     itemsLoc,
                     singularAttributes,
                 );
-            } else if (items !== undefined && items !== true) {
+            } else if (items !== undefined) {
                 return messageError(
                     "SchemaArrayItemsMustBeStringOrArray",
                     withRef(loc, { actual: items }),
@@ -1396,14 +1399,7 @@ async function addTypesInSchema(
 
         let result: TypeRef;
         if (typeof schema === "boolean") {
-            // FIXME: Empty union.  We'd have to check that it's supported everywhere,
-            // in particular in union flattening.
-            messageAssert(
-                schema === true,
-                "SchemaFalseNotSupported",
-                withRef(loc),
-            );
-            result = typeBuilder.getPrimitiveType("any");
+            result = typeBuilder.getPrimitiveType(schema ? "any" : "none");
         } else {
             loc = loc.updateWithID(schema.$id);
             result = await convertToType(schema, loc, typeAttributes);

packages/quicktype-core/src/language/CPlusPlus/CPlusPlusRenderer.ts

@@ -1597,6 +1597,12 @@ export class CPlusPlusRenderer extends ConvenienceRenderer {
                         getter = [name];
                     }
 
+                    const value = this._stringType.wrapEncodingChange(
+                        [ourQualifier],
+                        cppType,
+                        toType,
+                        ["x.", getter],
+                    );
                     const assignment: Sourcelike[] = [
                         "j[",
                         this._stringType.wrapEncodingChange(
@@ -1608,31 +1614,17 @@ export class CPlusPlusRenderer extends ConvenienceRenderer {
                             ]),
                         ),
                         "] = ",
-                        this._stringType.wrapEncodingChange(
-                            [ourQualifier],
-                            cppType,
-                            toType,
-                            ["x.", getter],
-                        ),
+                        value,
                         ";",
                     ];
                     if (p.isOptional && this._options.hideNullOptional) {
-                        this.emitBlock(
-                            [
-                                "if (",
-                                this._stringType.wrapEncodingChange(
-                                    [ourQualifier],
-                                    cppType,
-                                    toType,
-                                    ["x.", getter],
-                                ),
-                                ")",
-                            ],
-                            false,
-                            () => {
-                                this.emitLine(assignment);
-                            },
-                        );
+                        const condition =
+                            propType.kind === "null" || propType.kind === "any"
+                                ? ["!", value, ".is_null()"]
+                                : value;
+                        this.emitBlock(["if (", condition, ")"], false, () => {
+                            this.emitLine(assignment);
+                        });
                     } else {
                         this.emitLine(assignment);
                     }

packages/quicktype-core/src/language/CSharp/NewtonSoftCSharpRenderer.ts

@@ -408,7 +408,7 @@ export class NewtonsoftCSharpRenderer extends CSharpRenderer {
         this.emitType(
             undefined,
             AccessModifier.Public,
-            "static class",
+            "static partial class",
             "Serialize",
             undefined,
             () => {
@@ -471,7 +471,7 @@ export class NewtonsoftCSharpRenderer extends CSharpRenderer {
         this.emitType(
             undefined,
             AccessModifier.Internal,
-            "static class",
+            "static partial class",
             converterName,
             undefined,
             () => {

packages/quicktype-core/src/language/CSharp/SystemTextJsonCSharpRenderer.ts

@@ -416,7 +416,7 @@ export class SystemTextJsonCSharpRenderer extends CSharpRenderer {
         this.emitType(
             undefined,
             AccessModifier.Public,
-            "static class",
+            "static partial class",
             "Serialize",
             undefined,
             () => {
@@ -487,7 +487,7 @@ export class SystemTextJsonCSharpRenderer extends CSharpRenderer {
         this.emitType(
             undefined,
             AccessModifier.Internal,
-            "static class",
+            "static partial class",
             converterName,
             undefined,
             () => {

packages/quicktype-core/src/language/Golang/GolangRenderer.ts

@@ -12,7 +12,7 @@ import { assert, defined } from "../../support/Support.js";
 import type { TargetLanguage } from "../../TargetLanguage.js";
 import {
     type ClassProperty,
-    type ClassType,
+    ClassType,
     type EnumType,
     type Type,
     type TypeKind,
@@ -194,28 +194,37 @@ export class GoRenderer extends ConvenienceRenderer {
         if (
             this._options.multiFileOutput &&
             this._options.justTypes === false &&
-            this._options.justTypesAndPackage === false &&
-            this.leadingComments === undefined
+            this._options.justTypesAndPackage === false
         ) {
-            this.emitLineOnce(
-                "// Code generated from JSON Schema using quicktype. DO NOT EDIT.",
-            );
-            this.emitLineOnce(
-                "// To parse and unparse this JSON data, add this code to your project and do:",
-            );
-            this.emitLineOnce("//");
-            const ref = modifySource(camelCase, name);
-            this.emitLineOnce(
-                "//    ",
-                ref,
-                ", err := ",
-                defined(this._topLevelUnmarshalNames.get(name)),
-                "(bytes)",
-            );
-            this.emitLineOnce("//    bytes, err = ", ref, ".Marshal()");
+            if (this.leadingComments !== undefined) {
+                this.emitComments(this.leadingComments);
+            } else {
+                this.emitLineOnce(
+                    "// Code generated from JSON Schema using quicktype. DO NOT EDIT.",
+                );
+                this.emitLineOnce(
+                    "// To parse and unparse this JSON data, add this code to your project and do:",
+                );
+                this.emitLineOnce("//");
+                const ref = modifySource(camelCase, name);
+                this.emitLineOnce(
+                    "//    ",
+                    ref,
+                    ", err := ",
+                    defined(this._topLevelUnmarshalNames.get(name)),
+                    "(bytes)",
+                );
+                this.emitLineOnce("//    bytes, err = ", ref, ".Marshal()");
+            }
         }
 
-        this.emitPackageDefinitons(true);
+        const imports =
+            t instanceof ClassType
+                ? this.collectClassImports(t)
+                : t instanceof UnionType
+                  ? this.collectUnionImports(t)
+                  : undefined;
+        this.emitPackageDefinitons(true, imports);
 
         const unmarshalName = defined(this._topLevelUnmarshalNames.get(name));
         if (this.namedTypeToNameForTopLevel(t) === undefined) {
@@ -305,7 +314,7 @@ export class GoRenderer extends ConvenienceRenderer {
 
     private emitUnion(u: UnionType, unionName: Name): void {
         this.startFile(unionName);
-        this.emitPackageDefinitons(false);
+        this.emitPackageDefinitons(false, this.collectUnionImports(u));
         const [hasNull, nonNulls] = removeNullFromUnion(u);
         const isNullableArg = hasNull !== null ? "true" : "false";
 
@@ -610,10 +619,13 @@ func marshalUnion(pi *int64, pf *float64, pb *bool, ps *string, haveArray bool,
         if (
             this._options.multiFileOutput === false &&
             this._options.justTypes === false &&
-            this._options.justTypesAndPackage === false &&
-            this.leadingComments === undefined
+            this._options.justTypesAndPackage === false
         ) {
-            this.emitSingleFileHeaderComments();
+            if (this.leadingComments !== undefined) {
+                this.emitComments(this.leadingComments);
+            } else {
+                this.emitSingleFileHeaderComments();
+            }
             this.emitPackageDefinitons(false, this.collectAllImports());
         }
 

packages/quicktype-core/src/language/Golang/utils.ts

@@ -51,7 +51,8 @@ export function canOmitEmpty(
     omitEmptyOption: boolean,
 ): boolean {
     if (!cp.isOptional) return false;
-    if (omitEmptyOption) return true;
+    if (omitEmptyOption)
+        return !["union", "null", "any"].includes(cp.type.kind);
     const t = cp.type;
     return !["union", "null", "any"].includes(t.kind);
 }

packages/quicktype-core/src/language/Java/JavaJacksonRenderer.ts

@@ -10,7 +10,10 @@ import {
     type TypeKind,
     UnionType,
 } from "../../Type/index.js";
-import { removeNullFromUnion } from "../../Type/TypeUtils.js";
+import {
+    nullableFromUnion,
+    removeNullFromUnion,
+} from "../../Type/TypeUtils.js";
 
 import { JavaRenderer } from "./JavaRenderer.js";
 import { stringEscape } from "./utils.js";
@@ -58,7 +61,12 @@ export class JacksonRenderer extends JavaRenderer {
             `@JsonProperty("${stringEscape(jsonName)}")`,
         ];
 
-        switch (p.type.kind) {
+        const propertyType =
+            p.type instanceof UnionType
+                ? (nullableFromUnion(p.type) ?? p.type)
+                : p.type;
+
+        switch (propertyType.kind) {
             case "date-time":
                 this._dateTimeProvider.dateTimeJacksonAnnotations.forEach(
                     (annotation) => {

packages/quicktype-core/src/language/Kotlin/KotlinRenderer.ts

@@ -33,7 +33,7 @@ import {
 
 import { keywords } from "./constants.js";
 import type { kotlinOptions } from "./language.js";
-import { kotlinNameStyle } from "./utils.js";
+import { kotlinNameStyle, stringEscape } from "./utils.js";
 
 export class KotlinRenderer extends ConvenienceRenderer {
     public constructor(
@@ -391,10 +391,38 @@ export class KotlinRenderer extends ConvenienceRenderer {
     protected emitEnumDefinition(e: EnumType, enumName: Name): void {
         this.emitDescription(this.descriptionForType(e));
 
-        this.emitBlock(["enum class ", enumName], () => {
+        this.emitBlock(["enum class ", enumName, "(val value: String)"], () => {
             let count = e.cases.size;
-            this.forEachEnumCase(e, "none", (name) => {
-                this.emitLine(name, --count === 0 ? "" : ",");
+            this.forEachEnumCase(e, "none", (name, json) => {
+                this.emitLine(
+                    name,
+                    `("${stringEscape(json)}")`,
+                    --count === 0 ? ";" : ",",
+                );
+            });
+            this.ensureBlankLine();
+            this.emitBlock("companion object", () => {
+                this.emitBlock(
+                    [
+                        "fun fromValue(value: String): ",
+                        enumName,
+                        " = when (value)",
+                    ],
+                    () => {
+                        const table: Sourcelike[][] = [];
+                        this.forEachEnumCase(e, "none", (name, json) => {
+                            table.push([
+                                [`"${stringEscape(json)}"`],
+                                [" -> ", name],
+                            ]);
+                        });
+                        table.push([
+                            ["else"],
+                            [" -> throw IllegalArgumentException()"],
+                        ]);
+                        this.emitTable(table);
+                    },
+                );
             });
         });
     }