skir-java-gen 0.0.2

package/dist/index.js

@@ -0,0 +1,730 @@
+// TODO: add comments to generated code
+// TODO: add comments to records/fields/methods
+// TODO: s/field/variant for enums
+import { convertCase, } from "skir-internal";
+import { z } from "zod";
+import { Namer, toEnumConstantName } from "./naming.js";
+import { TypeSpeller } from "./type_speller.js";
+const Config = z.object({
+    packagePrefix: z
+        .string()
+        .regex(/^([a-z_$][a-z0-9_$]*\.)*$/)
+        .optional(),
+});
+class JavaCodeGenerator {
+    constructor() {
+        this.id = "java";
+        this.configType = Config;
+        this.version = "1.0.0";
+    }
+    generateCode(input) {
+        const { recordMap, config } = input;
+        const javaSourceFiles = [];
+        for (const module of input.modules) {
+            for (const record of module.records) {
+                if (record.recordAncestors.length !== 1) {
+                    // Only consider top-level records
+                    continue;
+                }
+                javaSourceFiles.push(new JavaSourceFileGenerator(record.record, module.path, recordMap, config));
+            }
+            if (module.methods.length > 0) {
+                javaSourceFiles.push(new JavaSourceFileGenerator({
+                    kind: "methods",
+                    methods: module.methods,
+                }, module.path, recordMap, config));
+            }
+            if (module.constants.length > 0) {
+                javaSourceFiles.push(new JavaSourceFileGenerator({
+                    kind: "constants",
+                    constants: module.constants,
+                }, module.path, recordMap, config));
+            }
+        }
+        const outputFiles = javaSourceFiles.map((sourceFile) => ({
+            path: sourceFile.path,
+            code: sourceFile.generate(),
+        }));
+        return { files: outputFiles };
+    }
+}
+// Generates the code for one Java file.
+class JavaSourceFileGenerator {
+    constructor(target, modulePath, recordMap, config) {
+        this.target = target;
+        this.modulePath = modulePath;
+        this.recordMap = recordMap;
+        this.code = "";
+        this.packagePrefix = config.packagePrefix ?? "";
+        this.namer = new Namer(this.packagePrefix);
+        this.typeSpeller = new TypeSpeller(recordMap, this.namer);
+    }
+    generate() {
+        // http://patorjk.com/software/taag/#f=Doom&t=Do%20not%20edit
+        this.push(`//  ______                        _               _  _  _
+      //  |  _  \\                      | |             | |(_)| |
+      //  | | | |  ___    _ __    ___  | |_    ___   __| | _ | |_
+      //  | | | | / _ \\  | '_ \\  / _ \\ | __|  / _ \\ / _\` || || __|
+      //  | |/ / | (_) | | | | || (_) || |_  |  __/| (_| || || |_ 
+      //  |___/   \\___/  |_| |_| \\___/  \\__|  \\___| \\__,_||_| \\__|
+      //
+
+      // To install the skir client library, add:
+      //   implementation("build.skir:skir-kotlin-client:latest.release")
+      // to your build.gradle file
+
+      `, `package ${this.packagePrefix}skirout.`, this.modulePath.replace(/\.skir$/, "").replace("/", "."), ";\n\n");
+        const { target } = this;
+        switch (target.kind) {
+            case "record": {
+                this.writeClassForRecord(target, "top-level");
+                break;
+            }
+            case "methods": {
+                this.writeClassForMethods(target.methods);
+                break;
+            }
+            case "constants": {
+                this.writeClassForConstants(target.constants);
+                break;
+            }
+            default: {
+                const _ = target;
+            }
+        }
+        return this.joinLinesAndFixFormatting();
+    }
+    writeClassForRecord(record, nested) {
+        if (record.recordType === "struct") {
+            this.writeClassForStruct(record, nested);
+        }
+        else {
+            this.writeClassForEnum(record, nested);
+        }
+    }
+    writeClassForStruct(record, nested) {
+        const { namer, recordMap, typeSpeller } = this;
+        const recordLocation = recordMap.get(record.key);
+        const className = this.namer.getClassName(recordLocation).name;
+        const fields = [...record.fields];
+        fields.sort((a, b) => a.name.text.localeCompare(b.name.text));
+        this.push("public ", nested === "nested" ? "static " : "", `final class ${className} {\n`);
+        // Declare fields
+        for (const field of fields) {
+            const fieldName = namer.structFieldToJavaName(field);
+            const type = typeSpeller.getJavaType(field.type, "frozen");
+            this.push(`private final ${type} ${fieldName};\n`);
+        }
+        const unrecognizedFieldsType = `build.skir.internal.UnrecognizedFields<${className}>`;
+        this.push(`private final ${unrecognizedFieldsType} _u;\n\n`);
+        // Constructor
+        this.push(`private ${className}(\n`);
+        for (const field of fields) {
+            const fieldName = namer.structFieldToJavaName(field);
+            const type = typeSpeller.getJavaType(field.type, "frozen");
+            this.push(`${type} ${fieldName},\n`);
+        }
+        this.push(`${unrecognizedFieldsType} _u\n`, ") {\n");
+        for (const field of fields) {
+            const fieldName = namer.structFieldToJavaName(field);
+            this.push(`this.${fieldName} = ${fieldName};\n`);
+        }
+        this.push("this._u = _u;\n", "}\n\n");
+        // DEFAULT instance
+        this.push(`private ${className}() {\n`);
+        for (const field of fields) {
+            const fieldName = namer.structFieldToJavaName(field);
+            if (field.isRecursive === "hard") {
+                this.push(`this.${fieldName} = null;\n`);
+            }
+            else {
+                const defaultExpr = this.getDefaultExpression(field.type);
+                this.push(`this.${fieldName} = ${defaultExpr};\n`);
+            }
+        }
+        this.push("this._u = null;\n", "}\n\n", `public static final ${className} DEFAULT = new ${className}();\n\n`);
+        // Getters
+        for (const field of fields) {
+            const fieldName = namer.structFieldToJavaName(field);
+            const type = typeSpeller.getJavaType(field.type, "frozen");
+            this.push(`public ${type} ${fieldName}() {\n`);
+            if (field.isRecursive === "hard") {
+                const defaultExpr = this.getDefaultExpression(field.type);
+                this.push(`if (this.${fieldName} != null) {\n`, `return this.${fieldName};\n`, `} else {\n`, `return ${defaultExpr};\n`, "}\n");
+            }
+            else {
+                this.push(`return this.${fieldName};\n`);
+            }
+            this.push("}\n\n");
+        }
+        // toBuilder()
+        this.push(`public Builder toBuilder() {\n`);
+        this.push(`return new Builder(\n`);
+        for (const field of fields) {
+            const fieldName = namer.structFieldToJavaName(field);
+            this.push(`this.${fieldName},\n`);
+        }
+        this.push("this._u);\n", "}\n\n");
+        // equals()
+        this.push("@java.lang.Override\n", "public boolean equals(Object other) {\n", "if (this == other) return true;\n", `if (!(other instanceof ${className})) return false;\n`, `return java.util.Arrays.equals(_equalsProxy(), ((${className}) other)._equalsProxy());\n`, "}\n\n");
+        // hashCode()
+        this.push("@java.lang.Override\n", "public int hashCode() {\n", "return java.util.Arrays.hashCode(_equalsProxy());\n", "}\n\n");
+        // toString()
+        this.push("@java.lang.Override\n", "public java.lang.String toString() {\n", `return SERIALIZER.toJsonCode(this, build.skir.JsonFlavor.READABLE);\n`, "}\n\n");
+        // _equalsProxy()
+        this.push("private Object[] _equalsProxy() {\n", "return new Object[] {\n", fields
+            .map((field) => "this." + namer.structFieldToJavaName(field))
+            .join(",\n"), "\n};\n", "}\n\n");
+        // builder()
+        {
+            const firstField = fields[0];
+            const retType = firstField
+                ? "Builder_At" + convertCase(firstField.name.text, "UpperCamel")
+                : "Builder_Done";
+            this.push(`public static ${retType} builder() {\n`, "return new Builder();\n", "}\n\n");
+        }
+        // partialBuilder()
+        this.push("public static Builder partialBuilder() {\n", "return new Builder();\n", "}\n\n");
+        // Builder_At? interfaces
+        for (const [index, field] of fields.entries()) {
+            const fieldName = namer.structFieldToJavaName(field);
+            const nextField = index < fields.length - 1 ? fields[index + 1] : null;
+            const upperCamelName = convertCase(field.name.text, "UpperCamel");
+            const retType = nextField
+                ? "Builder_At" + convertCase(nextField.name.text, "UpperCamel")
+                : "Builder_Done";
+            const paramType = typeSpeller.getJavaType(field.type, "initializer");
+            this.push(`public interface Builder_At${upperCamelName} {\n`, `${retType} set${upperCamelName}(${paramType} ${fieldName});\n`, "}\n\n");
+        }
+        this.push(`public interface Builder_Done {\n`, `${className} build();\n`, "}\n\n");
+        // Builder class
+        this.push("public static final class Builder implements ");
+        for (const field of fields) {
+            const upperCamelName = convertCase(field.name.text, "UpperCamel");
+            this.push(`Builder_At${upperCamelName}, `);
+        }
+        this.push("Builder_Done {\n");
+        // Builder fields
+        for (const field of fields) {
+            const fieldName = namer.structFieldToJavaName(field);
+            const type = typeSpeller.getJavaType(field.type, "frozen");
+            this.push(`private ${type} ${fieldName};\n`);
+        }
+        this.push(`private ${unrecognizedFieldsType} _u;\n\n`);
+        // Builder constructors
+        this.push("private Builder(\n");
+        for (const field of fields) {
+            const fieldName = namer.structFieldToJavaName(field);
+            const type = typeSpeller.getJavaType(field.type, "frozen");
+            this.push(`${type} ${fieldName},\n`);
+        }
+        this.push(`${unrecognizedFieldsType} _u\n`, ") {\n");
+        for (const field of fields) {
+            const fieldName = namer.structFieldToJavaName(field);
+            this.push(`this.${fieldName} = ${fieldName};\n`);
+        }
+        this.push("this._u = _u;\n", "}\n\n");
+        this.push("private Builder() {\n");
+        for (const field of fields) {
+            const fieldName = namer.structFieldToJavaName(field);
+            const defaultExpr = this.getDefaultExpression(field.type);
+            this.push(`this.${fieldName} = ${defaultExpr};\n`);
+        }
+        this.push("this._u = null;\n", "}\n\n");
+        // Setters
+        for (const field of fields) {
+            const fieldName = namer.structFieldToJavaName(field);
+            const upperCamelName = convertCase(field.name.text, "UpperCamel");
+            const type = field.type;
+            const javaType = typeSpeller.getJavaType(type, "initializer");
+            this.push("@java.lang.Override\n", `public Builder set${upperCamelName}(${javaType} ${fieldName}) {\n`);
+            const toFrozenExpr = this.toFrozenExpression(fieldName, type, "can-be-null", "_e");
+            this.push(`this.${fieldName} = ${toFrozenExpr};\n`, "return this;\n", "}\n\n");
+            const isStruct = type.kind === "record" &&
+                recordMap.get(type.key).record.recordType === "struct";
+            if (isStruct) {
+                const updaterType = `java.util.function.Function<? super ${javaType}, ? extends ${javaType}>`;
+                this.push(`public Builder update${upperCamelName}(${updaterType} updater) {\n`, `return set${upperCamelName}(updater.apply(this.${fieldName}));\n`, "}\n\n");
+            }
+        }
+        this.push("@java.lang.Override\n", `public ${className} build() {\n`, `return new ${className}(\n`);
+        for (const field of fields) {
+            const fieldName = namer.structFieldToJavaName(field);
+            this.push(`this.${fieldName},\n`);
+        }
+        this.push("this._u);\n", "}\n\n");
+        this.push("}\n\n");
+        // _serializerImpl
+        {
+            const serializerType = `build.skir.internal.StructSerializer<${className}, ${className}.Builder>`;
+            this.push(`private static final ${serializerType} _serializerImpl = (\n`, "new build.skir.internal.StructSerializer<>(\n", `"${getRecordId(recordLocation)}",\n`, `${toJavaStringLiteral(docToCommentText(record.doc))},\n`, "DEFAULT,\n", `(${className} it) -> it != null ? it.toBuilder() : partialBuilder(),\n`, `(${className}.Builder it) -> it.build(),\n`, `(${className} it) -> it._u,\n`, `(${className}.Builder builder, ${unrecognizedFieldsType} u) -> {\n`, `builder._u = u;\n`, "return null;\n", "}\n", ")\n", ");\n\n");
+        }
+        // SERIALIZER
+        this.push(`public static final build.skir.Serializer<${className}> SERIALIZER = (\n`, "build.skir.internal.SerializersKt.makeSerializer(_serializerImpl)\n", ");\n\n");
+        // TYPE_DESCRIPTOR
+        {
+            const typeDescriptorType = `build.skir.reflection.StructDescriptor.Reflective<${className}, ${className}.Builder>`;
+            this.push(`public static final ${typeDescriptorType} TYPE_DESCRIPTOR = (\n`, "_serializerImpl\n", ");\n\n");
+        }
+        // Finalize serializer
+        this.push("static {\n");
+        for (const field of fields) {
+            const skirName = field.name.text;
+            const javadName = namer.structFieldToJavaName(field);
+            this.push("_serializerImpl.addField(\n", `"${skirName}",\n`, '"",\n', `${field.number},\n`, `${typeSpeller.getSerializerExpression(field.type)},\n`, `${toJavaStringLiteral(docToCommentText(field.doc))},\n`, `(it) -> it.${javadName}(),\n`, "(builder, v) -> {\n", `builder.${javadName} = v;\n`, "return null;\n", "}\n", ");\n");
+        }
+        for (const removedNumber of record.removedNumbers) {
+            this.push(`_serializerImpl.addRemovedNumber(${removedNumber});\n`);
+        }
+        this.push("_serializerImpl.finalizeStruct();\n", "}\n\n");
+        // Nested classes
+        this.writeClassesForNestedRecords(record);
+        this.push("}\n\n");
+    }
+    writeClassForEnum(record, nested) {
+        const { recordMap, typeSpeller } = this;
+        const recordLocation = recordMap.get(record.key);
+        const className = this.namer.getClassName(recordLocation).name;
+        const { fields } = record;
+        const constantFields = fields.filter((f) => !f.type);
+        const wrapperFields = fields.filter((f) => f.type);
+        this.push("public ", nested === "nested" ? "static " : "", `final class ${className} {\n`);
+        // Kind enum
+        this.push("public enum Kind {\n", "UNKNOWN,\n");
+        for (const field of constantFields) {
+            this.push(field.name.text, "_CONST,\n");
+        }
+        for (const field of wrapperFields) {
+            this.push(convertCase(field.name.text, "UPPER_UNDERSCORE"), "_WRAPPER,\n");
+        }
+        this.push("}\n\n");
+        // Constants
+        this.push(`public static final ${className} UNKNOWN = new ${className}(Kind.UNKNOWN, null);\n`);
+        for (const field of constantFields) {
+            const skirName = field.name.text;
+            const name = toEnumConstantName(field);
+            this.push(`public static final ${className} ${name} = new ${className}(Kind.${skirName}_CONST, null);\n`);
+        }
+        this.pushEol();
+        // WrapX methods
+        for (const field of wrapperFields) {
+            const upperCamelName = convertCase(field.name.text, "UpperCamel");
+            const upperUnderscoreName = convertCase(field.name.text, "UPPER_UNDERSCORE");
+            const type = field.type;
+            const initializerType = typeSpeller.getJavaType(type, "initializer");
+            const frozenType = typeSpeller.getJavaType(type, "frozen");
+            const toFrozenExpr = this.toFrozenExpression("value", type, "can-be-null", "_e");
+            this.push(`public static ${className} wrap${upperCamelName}(${initializerType} value) {\n`, `final ${frozenType} v = ${toFrozenExpr};\n`, `return new ${className}(Kind.${upperUnderscoreName}_WRAPPER, v);\n`, "}\n\n");
+        }
+        // Declare fields
+        this.push("private final Kind kind;\n", "private final java.lang.Object value;\n\n");
+        // Constructor
+        this.push(`private ${className}(Kind kind, java.lang.Object value) {\n`, "this.kind = kind;\n", "this.value = value;\n", "}\n\n");
+        // kind()
+        this.push("public Kind kind() {\n", "return kind;\n", "}\n\n");
+        // asX() methods
+        for (const field of wrapperFields) {
+            const type = typeSpeller.getJavaType(field.type, "frozen");
+            const upperCamelName = convertCase(field.name.text, "UpperCamel");
+            const upperUnderscoreName = convertCase(field.name.text, "UPPER_UNDERSCORE");
+            this.push(`public ${type} as${upperCamelName}() {\n`, `if (kind != Kind.${upperUnderscoreName}_WRAPPER) {\n`, `throw new java.lang.IllegalStateException("kind=" + kind.name());\n`, "}\n", `return (${type}) value;\n`, "}\n\n");
+        }
+        // Visitor
+        this.push("public interface Visitor<R> {\n", "R onUnknown();\n");
+        for (const field of constantFields) {
+            const upperCamelName = convertCase(field.name.text, "UpperCamel");
+            this.push(`R on${upperCamelName}();\n`);
+        }
+        for (const field of wrapperFields) {
+            const upperCamelName = convertCase(field.name.text, "UpperCamel");
+            const type = typeSpeller.getJavaType(field.type, "frozen");
+            this.push(`R on${upperCamelName}(${type} value);\n`);
+        }
+        this.push("}\n\n");
+        // accept()
+        this.push("public <R> R accept(Visitor<R> visitor) {\n", "return switch (kind) {\n");
+        for (const field of constantFields) {
+            const upperUnderscoreName = field.name.text;
+            const upperCamelName = convertCase(field.name.text, "UpperCamel");
+            this.push(`case ${upperUnderscoreName}_CONST -> visitor.on${upperCamelName}();\n`);
+        }
+        for (const field of wrapperFields) {
+            const upperUnderscoreName = convertCase(field.name.text, "UPPER_UNDERSCORE");
+            const upperCamelName = convertCase(field.name.text, "UpperCamel");
+            const type = typeSpeller.getJavaType(field.type, "frozen");
+            this.push(`case ${upperUnderscoreName}_WRAPPER -> visitor.on${upperCamelName}((${type}) value);\n`);
+        }
+        this.push("default -> visitor.onUnknown();\n", "};\n", "}\n\n");
+        // equals()
+        this.push("@java.lang.Override\n", "public boolean equals(Object other) {\n", `if (!(other instanceof ${className})) return false;\n`, `final ${className} otherEnum = (${className}) other;\n`, "if (kind == Kind.UNKNOWN) return otherEnum.kind == Kind.UNKNOWN;\n", "return kind == otherEnum.kind && java.util.Objects.equals(value, otherEnum.value);\n", "}\n\n");
+        // hashCode()
+        this.push("@java.lang.Override\n", "public int hashCode() {\n", "final Object v = kind == Kind.UNKNOWN ? null : value;\n", "return 31 * java.util.Objects.hashCode(v) + kind.ordinal();\n", "}\n\n");
+        // toString()
+        this.push("@java.lang.Override\n", "public java.lang.String toString() {\n", `return SERIALIZER.toJsonCode(this, build.skir.JsonFlavor.READABLE);\n`, "}\n\n");
+        // _serializerImpl
+        {
+            const serializerType = `build.skir.internal.EnumSerializer<${className}>`;
+            const unrecognizedVariantType = `build.skir.internal.UnrecognizedVariant<${className}>`;
+            this.push(`private static final ${serializerType} _serializerImpl = (\n`, "build.skir.internal.EnumSerializer.Companion.create(\n", `"${getRecordId(recordLocation)}",\n`, `${toJavaStringLiteral(docToCommentText(record.doc))},\n`, `(${className} it) -> it.kind().ordinal(),\n`, "Kind.values().length,\n", "UNKNOWN,\n", `(${unrecognizedVariantType} it) -> new ${className}(Kind.UNKNOWN, it),\n`, `(${className} it) -> (${unrecognizedVariantType}) it.value\n`, ")\n", ");\n\n");
+        }
+        // SERIALIZER
+        this.push(`public static final build.skir.Serializer<${className}> SERIALIZER = (\n`, "build.skir.internal.SerializersKt.makeSerializer(_serializerImpl)\n", ");\n\n");
+        // TYPE_DESCRIPTOR
+        {
+            const typeDescriptorType = `build.skir.reflection.EnumDescriptor.Reflective<${className}>`;
+            this.push(`public static final ${typeDescriptorType} TYPE_DESCRIPTOR = (\n`, "_serializerImpl\n", ");\n\n");
+        }
+        // Finalize serializer
+        this.push("static {\n");
+        for (const field of constantFields) {
+            const name = field.name.text;
+            this.push("_serializerImpl.addConstantVariant(\n", `${field.number},\n`, `"${name}",\n`, `Kind.${name}_CONST.ordinal(),\n`, `${toJavaStringLiteral(docToCommentText(field.doc))},\n`, `${toEnumConstantName(field)}\n`, ");\n");
+        }
+        for (const field of wrapperFields) {
+            const type = field.type;
+            const javaType = typeSpeller.getJavaType(type, "frozen", "must-be-object");
+            const serializerExpression = typeSpeller.getSerializerExpression(type);
+            const skirName = field.name.text;
+            const upperCamelName = convertCase(skirName, "UpperCamel");
+            const kindConstName = convertCase(skirName, "UPPER_UNDERSCORE") + "_WRAPPER";
+            this.push("_serializerImpl.addWrapperVariant(\n", `${field.number},\n`, `"${field.name.text}",\n`, `Kind.${kindConstName}.ordinal(),\n`, `${serializerExpression},\n`, `${toJavaStringLiteral(docToCommentText(field.doc))},\n`, `(${javaType} it) -> wrap${upperCamelName}(it),\n`, `(${className} it) -> it.as${upperCamelName}()\n`, ");\n");
+        }
+        for (const removedNumber of record.removedNumbers) {
+            this.push(`_serializerImpl.addRemovedNumber(${removedNumber});\n`);
+        }
+        this.push("_serializerImpl.finalizeEnum();\n", "}\n\n");
+        // Nested classes
+        this.writeClassesForNestedRecords(record);
+        this.push("}\n\n");
+    }
+    writeClassesForNestedRecords(record) {
+        for (const nestedRecord of record.nestedRecords) {
+            this.writeClassForRecord(nestedRecord, "nested");
+        }
+    }
+    get path() {
+        const { target, modulePath } = this;
+        let className;
+        switch (target.kind) {
+            case "record": {
+                const record = this.recordMap.get(target.key);
+                className = this.namer.getClassName(record).name;
+                break;
+            }
+            case "methods": {
+                className = "Methods";
+                break;
+            }
+            case "constants": {
+                className = "Constants";
+                break;
+            }
+        }
+        return modulePath.replace(/\.skir$/, "") + `/${className}.java`;
+    }
+    writeClassForMethods(methods) {
+        this.push("public final class Methods {\n\n", "private Methods() {}\n\n");
+        for (const method of methods) {
+            this.writeMethod(method);
+        }
+        this.push("}\n\n");
+    }
+    writeMethod(method) {
+        const { typeSpeller } = this;
+        const requestType = typeSpeller.getJavaType(method.requestType, "frozen");
+        const requestSerializer = typeSpeller.getSerializerExpression(method.requestType);
+        const responseType = typeSpeller.getJavaType(method.responseType, "frozen");
+        const responseSerializer = typeSpeller.getSerializerExpression(method.responseType);
+        const skirName = method.name.text;
+        const javaName = convertCase(skirName, "UPPER_UNDERSCORE");
+        const methodType = `build.skir.service.Method<${requestType}, ${responseType}>`;
+        this.push(`public static final ${methodType} ${javaName} = (\n`, "new build.skir.service.Method<>(\n", `"${skirName}",\n`, `${method.number}L,\n`, `${requestSerializer},\n`, `${responseSerializer},\n`, `${toJavaStringLiteral(docToCommentText(method.doc))}\n`, ")\n", ");\n\n");
+    }
+    writeClassForConstants(constants) {
+        this.push("public final class Constants {\n\n", "private Constants() {}\n\n");
+        for (const constant of constants) {
+            this.writeConstant(constant);
+        }
+        this.push("}\n\n");
+    }
+    writeConstant(constant) {
+        const { typeSpeller } = this;
+        const javaType = typeSpeller.getJavaType(constant.type, "frozen");
+        const name = constant.name.text;
+        const serializerExpression = typeSpeller.getSerializerExpression(constant.type);
+        const jsonStringLiteral = JSON.stringify(JSON.stringify(constant.valueAsDenseJson));
+        this.push(`public static final ${javaType} ${name} = (\n`, `${serializerExpression}.fromJsonCode(${jsonStringLiteral})\n`, ");\n\n");
+    }
+    getDefaultExpression(type) {
+        switch (type.kind) {
+            case "primitive": {
+                switch (type.primitive) {
+                    case "bool":
+                        return "false";
+                    case "int32":
+                    case "int64":
+                    case "uint64":
+                        return "0";
+                    case "float32":
+                        return "0.0f";
+                    case "float64":
+                        return "0.0";
+                    case "timestamp":
+                        return "java.time.Instant.EPOCH";
+                    case "string":
+                        return '""';
+                    case "bytes":
+                        return "okio.ByteString.EMPTY";
+                    default: {
+                        const _ = type.primitive;
+                        throw Error();
+                    }
+                }
+            }
+            case "array": {
+                if (type.key) {
+                    return `build.skir.internal.FrozenListKt.emptyKeyedList()`;
+                }
+                else {
+                    return `build.skir.internal.FrozenListKt.emptyFrozenList()`;
+                }
+            }
+            case "optional": {
+                return "java.util.Optional.empty()";
+            }
+            case "record": {
+                const record = this.typeSpeller.recordMap.get(type.key);
+                const kotlinType = this.typeSpeller.getJavaType(type, "frozen");
+                switch (record.record.recordType) {
+                    case "struct": {
+                        return `${kotlinType}.DEFAULT`;
+                    }
+                    case "enum": {
+                        return `${kotlinType}.UNKNOWN`;
+                    }
+                }
+                break;
+            }
+        }
+    }
+    toFrozenExpression(inputExpr, type, nullability, it) {
+        const { namer } = this;
+        switch (type.kind) {
+            case "primitive": {
+                switch (type.primitive) {
+                    case "bool":
+                    case "int32":
+                    case "int64":
+                    case "uint64":
+                    case "float32":
+                    case "float64":
+                        return inputExpr;
+                    case "timestamp":
+                    case "string":
+                    case "bytes":
+                        return nullability === "can-be-null"
+                            ? `java.util.Objects.requireNonNull(${inputExpr})`
+                            : inputExpr;
+                    default: {
+                        const _ = type.primitive;
+                        throw Error();
+                    }
+                }
+            }
+            case "array": {
+                const itemToFrozenExpr = this.toFrozenExpression(it, type.item, "can-be-null", it + "_");
+                const frozenListKt = "build.skir.internal.FrozenListKt";
+                if (type.key) {
+                    const path = type.key.path
+                        .map((f) => namer.structFieldToJavaName(f.name.text) + "()")
+                        .join(".");
+                    if (itemToFrozenExpr === it) {
+                        return `${frozenListKt}.toKeyedList(\n${inputExpr},\n"${path}",\n(${it}) -> ${it}.${path}\n)`;
+                    }
+                    else {
+                        return `${frozenListKt}.toKeyedList(\n${inputExpr},\n"${path}",\n(${it}) -> ${it}.${path},\n(${it}) -> ${itemToFrozenExpr}\n)`;
+                    }
+                }
+                else {
+                    if (itemToFrozenExpr === it) {
+                        return `${frozenListKt}.toFrozenList(${inputExpr})`;
+                    }
+                    else {
+                        return `${frozenListKt}.toFrozenList(\n${inputExpr},\n(${it}) -> ${itemToFrozenExpr}\n)`;
+                    }
+                }
+            }
+            case "optional": {
+                const otherExpr = this.toFrozenExpression(it, type.other, "never-null", it + "_");
+                return `${inputExpr}.map(\n(${it}) -> ${otherExpr}\n)`;
+            }
+            case "record": {
+                return nullability === "can-be-null"
+                    ? `java.util.Objects.requireNonNull(${inputExpr})`
+                    : inputExpr;
+            }
+        }
+    }
+    push(...code) {
+        this.code += code.join("");
+    }
+    pushEol() {
+        this.code += "\n";
+    }
+    joinLinesAndFixFormatting() {
+        const indentUnit = "  ";
+        let result = "";
+        // The indent at every line is obtained by repeating indentUnit N times,
+        // where N is the length of this array.
+        const contextStack = [];
+        // Returns the last element in `contextStack`.
+        const peakTop = () => contextStack.at(-1);
+        const getMatchingLeftBracket = (r) => {
+            switch (r) {
+                case "}":
+                    return "{";
+                case ")":
+                    return "(";
+                case "]":
+                    return "[";
+                case ">":
+                    return "<";
+            }
+        };
+        for (let line of this.code.split("\n")) {
+            line = line.trim();
+            if (line.length <= 0) {
+                // Don't indent empty lines.
+                result += "\n";
+                continue;
+            }
+            const firstChar = line[0];
+            switch (firstChar) {
+                case "}":
+                case ")":
+                case "]":
+                case ">": {
+                    const left = getMatchingLeftBracket(firstChar);
+                    while (contextStack.pop() !== left) {
+                        if (contextStack.length <= 0) {
+                            throw Error();
+                        }
+                    }
+                    break;
+                }
+                case ".": {
+                    if (peakTop() !== ".") {
+                        contextStack.push(".");
+                    }
+                    break;
+                }
+            }
+            const indent = indentUnit.repeat(contextStack.length);
+            result += `${indent}${line.trimEnd()}\n`;
+            if (line.startsWith("//")) {
+                continue;
+            }
+            const lastChar = line.slice(-1);
+            switch (lastChar) {
+                case "{":
+                case "(":
+                case "[":
+                case "<": {
+                    // The next line will be indented
+                    contextStack.push(lastChar);
+                    break;
+                }
+                case ":":
+                case "=": {
+                    if (peakTop() !== ":") {
+                        contextStack.push(":");
+                    }
+                    break;
+                }
+                case ";":
+                case ",": {
+                    if (peakTop() === "." || peakTop() === ":") {
+                        contextStack.pop();
+                    }
+                }
+            }
+        }
+        return (result
+            // Remove spaces enclosed within curly brackets if that's all there is.
+            .replace(/\{\s+\}/g, "{}")
+            // Remove spaces enclosed within round brackets if that's all there is.
+            .replace(/\(\s+\)/g, "()")
+            // Remove spaces enclosed within square brackets if that's all there is.
+            .replace(/\[\s+\]/g, "[]")
+            // Remove empty line following an open curly bracket.
+            .replace(/(\{\n *)\n/g, "$1")
+            // Remove empty line preceding a closed curly bracket.
+            .replace(/\n(\n *\})/g, "$1")
+            // Coalesce consecutive empty lines.
+            .replace(/\n\n\n+/g, "\n\n")
+            .replace(/\n\n$/g, "\n"));
+    }
+}
+function getRecordId(struct) {
+    const modulePath = struct.modulePath;
+    const qualifiedRecordName = struct.recordAncestors
+        .map((r) => r.name.text)
+        .join(".");
+    return `${modulePath}:${qualifiedRecordName}`;
+}
+function toJavaStringLiteral(input) {
+    const escaped = input.replace(/[\\"\x00-\x1f\x7f-\xff]/g, (char) => {
+        switch (char) {
+            case '"':
+                return '\\"';
+            case "\\":
+                return "\\\\";
+            case "\b":
+                return "\\b";
+            case "\f":
+                return "\\f";
+            case "\n":
+                return "\\n";
+            case "\r":
+                return "\\r";
+            case "\t":
+                return "\\t";
+            default: {
+                // Handle non-printable characters using Unicode escapes (\\uXXXX)
+                const code = char.charCodeAt(0).toString(16).padStart(4, "0");
+                return `\\u${code}`;
+            }
+        }
+    });
+    return `"${escaped}"`;
+}
+function commentify(textOrLines) {
+    const text = (typeof textOrLines === "string" ? textOrLines : textOrLines.join("\n"))
+        .trim()
+        .replace(/\n{3,}/g, "\n\n")
+        .replace("*/", "* /");
+    if (text.length <= 0) {
+        return "";
+    }
+    const lines = text.split("\n");
+    if (lines.length === 1) {
+        return `/** ${text} */\n`;
+    }
+    else {
+        return ["/**\n", ...lines.map((line) => ` * ${line}\n`), " */\n"].join("");
+    }
+}
+function docToCommentText(doc) {
+    return doc.pieces
+        .map((p) => {
+        switch (p.kind) {
+            case "text":
+                return p.text;
+            case "reference":
+                return "`" + p.referenceRange.text.slice(1, -1) + "`";
+        }
+    })
+        .join("");
+}
+export const GENERATOR = new JavaCodeGenerator();
+//# sourceMappingURL=index.js.map