skir-rust-gen 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Tyler Fibonacci
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { type CodeGenerator } from "skir-internal";
+import { z } from "zod";
+declare const Config: z.ZodObject<{}, z.core.$strict>;
+type Config = z.infer<typeof Config>;
+declare class RustCodeGenerator implements CodeGenerator<Config> {
+    readonly id = "skir-rust-gen";
+    readonly configType: z.ZodObject<{}, z.core.$strict>;
+    generateCode(input: CodeGenerator.Input<Config>): CodeGenerator.Output;
+}
+export declare const GENERATOR: RustCodeGenerator;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EASnB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,QAAA,MAAM,MAAM,iCAAqB,CAAC;AAElC,KAAK,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAErC,cAAM,iBAAkB,YAAW,aAAa,CAAC,MAAM,CAAC;IACtD,QAAQ,CAAC,EAAE,mBAAmB;IAC9B,QAAQ,CAAC,UAAU,kCAAU;IAE7B,YAAY,CAAC,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,aAAa,CAAC,MAAM;CAevE;AA+tBD,eAAO,MAAM,SAAS,mBAA0B,CAAC"}

package/dist/index.js

@@ -0,0 +1,611 @@
+import { convertCase, } from "skir-internal";
+import { z } from "zod";
+import { KeyedArrayContext } from "./keyed_array_context.js";
+import { getTypeName, isUpperCasedKeyword, Namer, toStructFieldName as toRustFieldName, } from "./naming.js";
+import { collectRustModuleSpecs } from "./rust_module_spec.js";
+import { skirDefaultIsRustDefault, TypeSpeller } from "./type_speller.js";
+const Config = z.strictObject({});
+class RustCodeGenerator {
+    constructor() {
+        this.id = "skir-rust-gen";
+        this.configType = Config;
+    }
+    generateCode(input) {
+        const { recordMap, config } = input;
+        const keyedArrayContext = new KeyedArrayContext(input.modules);
+        const rustModuleSpecs = collectRustModuleSpecs(input.modules);
+        const outputFiles = rustModuleSpecs.map((moduleSpec) => ({
+            path: moduleSpec.path,
+            code: new RustSourceFileGenerator(moduleSpec, recordMap, keyedArrayContext, config).generate(),
+        }));
+        return { files: outputFiles };
+    }
+}
+// Generates the code for one Rust file.
+class RustSourceFileGenerator {
+    constructor(moduleSpec, recordMap, keyedArrayContext, config) {
+        this.moduleSpec = moduleSpec;
+        this.keyedArrayContext = keyedArrayContext;
+        this.config = config;
+        this.code = "";
+        this.namer = new Namer(moduleSpec.skirModule);
+        this.typeSpeller = new TypeSpeller(recordMap, this.namer);
+    }
+    generate() {
+        // const packageName = skirModulePathToSkiroutPath(this.inModule.path);
+        // http://patorjk.com/software/taag/#f=Doom&t=Do%20not%20edit
+        this.push(`#![allow(nonstandard_style)]
+
+      //  ______                        _               _  _  _
+      //  |  _  \\                      | |             | |(_)| |
+      //  | | | |  ___    _ __    ___  | |_    ___   __| | _ | |_
+      //  | | | | / _ \\  | '_ \\  / _ \\ | __|  / _ \\ / _\` || || __|
+      //  | |/ / | (_) | | | | || (_) || |_  |  __/| (_| || || |_ 
+      //  |___/   \\___/  |_| |_| \\___/  \\__|  \\___| \\__,_||_| \\__|
+      //
+      // Generated by skir-rust-gen
+      // Home: https://github.com/gepheum/skir-rust-gen
+      //
+      // To install the Skir client library, run:
+      //   cargo add skir-rust-client
+      `);
+        for (const childModuleName of this.moduleSpec.childModuleNames) {
+            this.push(`pub mod ${childModuleName};\n`);
+        }
+        this.push("\n");
+        const skirModule = this.moduleSpec.skirModule;
+        if (skirModule) {
+            const { constants, methods, records } = skirModule;
+            if (records.length) {
+                for (const record of records) {
+                    const { recordType } = record.record;
+                    if (recordType === "struct") {
+                        this.writeStruct(record);
+                    }
+                    else {
+                        this.writeEnum(record);
+                    }
+                }
+                this.writeInitializeModuleSerializersFn(records);
+            }
+            if (methods.length) {
+                this.pushSeparator("Methods");
+                for (const method of methods) {
+                    this.writeMethod(method);
+                }
+            }
+            if (constants.length) {
+                this.pushSeparator("Constants");
+                for (const constant of constants) {
+                    this.writeConstant(constant);
+                }
+            }
+        }
+        return this.joinLinesAndFixFormatting();
+    }
+    writeStruct(struct) {
+        const { namer, typeSpeller } = this;
+        this.pushSeparator("struct ".concat(struct.recordAncestors.map((r) => r.name.text).join(".")));
+        const typeName = getTypeName(struct);
+        const allFieldsUseRustDefault = struct.record.fields.every((f) => f.isRecursive === "hard" || skirDefaultIsRustDefault(f.type));
+        const deriveList = allFieldsUseRustDefault
+            ? `${namer.clone}, ${namer.debug}, ${namer.partialEq}, ${namer.default}`
+            : `${namer.clone}, ${namer.debug}, ${namer.partialEq}`;
+        this.push(commentify(docToCommentText(struct.record.doc)));
+        this.push(`#[derive(${deriveList})]\n`);
+        this.push(`pub struct ${typeName} {\n`);
+        for (const field of struct.record.fields) {
+            const fieldType = typeSpeller.getRustType(field.type);
+            const fieldName = toRustFieldName(field.name.text);
+            if (field.isRecursive === "hard") {
+                const recFieldName = `_${field.name.text}_rec`;
+                const boxedType = `${namer.option}<${namer.box}<${fieldType}>>`;
+                this.push(commentify([
+                    docToCommentText(field.doc),
+                    "Recursive field. Noxed and optional to avoid infinite size.",
+                    "None is equivalent to the default value.",
+                    `Use \`${fieldName}()\` to read this field without having to handle the Option,`,
+                    "but be careful not to call it from a recursive function as it may cause",
+                    "infinite recursion.",
+                ]));
+                this.push(`pub ${recFieldName}: ${boxedType},\n`);
+            }
+            else {
+                this.push(commentify(docToCommentText(field.doc)));
+                this.push(`pub ${fieldName}: ${fieldType},\n`);
+            }
+        }
+        this.push(commentify("Set this to None when you're creating a struct."));
+        this.push(`pub _unrecognized: ${namer.option}<crate::skir_client::UnrecognizedFields<${typeName}>>,\n`);
+        this.push("}\n\n");
+        // impl block: default_ref() + getters for hard-recursive fields
+        const hardRecursiveFields = struct.record.fields.filter((f) => f.isRecursive === "hard");
+        this.push(`impl ${typeName} {\n`);
+        // default_ref()
+        this.push(`pub fn default_ref() -> &'static ${typeName} {\n`);
+        this.push(`static D: std::sync::LazyLock<${typeName}> = std::sync::LazyLock::new(${typeName}::default);\n`);
+        this.push("&D\n");
+        this.push("}\n");
+        // Getters for hard-recursive fields
+        for (const field of hardRecursiveFields) {
+            const getterName = toRustFieldName(field.name.text);
+            const fieldType = typeSpeller.getRustType(field.type);
+            this.push(commentify(docToCommentText(field.doc)));
+            this.push(`pub fn ${getterName}(&self) -> &${fieldType} {\n`);
+            this.push(`match &self._${field.name.text}_rec {\n`);
+            this.push(`Some(boxed) => boxed.as_ref(),\n`);
+            this.push(`None => ${fieldType}::default_ref(),\n`);
+            this.push("}\n");
+            this.push("}\n");
+        }
+        this.push("}\n\n");
+        // Manual Default impl — only needed when #[derive(Default)] can't be used.
+        if (!allFieldsUseRustDefault) {
+            this.push(`impl ${namer.default} for ${typeName} {\n`);
+            this.push(`fn default() -> Self {\n`);
+            this.push(`${typeName} {\n`);
+            for (const field of struct.record.fields) {
+                if (field.isRecursive === "hard") {
+                    this.push(`_${field.name.text}_rec: None,\n`);
+                }
+                else {
+                    const fieldName = toRustFieldName(field.name.text);
+                    const defaultExpr = typeSpeller.getDefaultExpr(field.type);
+                    this.push(`${fieldName}: ${defaultExpr},\n`);
+                }
+            }
+            this.push(`_unrecognized: None,\n`);
+            this.push("}\n");
+            this.push("}\n");
+            this.push("}\n\n");
+        }
+        // Write a KeyedVecSpec impl for each keyed array that has this struct as item type.
+        for (const keySpec of this.keyedArrayContext.getKeySpecsForItemStruct(struct.record, typeSpeller)) {
+            this.push(`pub struct ${keySpec.rustSpecName};\n\n`);
+            this.push(`impl crate::skir_client::KeyedVecSpec for ${keySpec.rustSpecName} {\n`);
+            this.push(`type Item = ${typeName};\n`);
+            this.push(`type StorageKey = ${keySpec.rustKeyType};\n`);
+            this.push(`type Lookup = crate::skir_client::internal::${keySpec.lookupImpl};\n`);
+            this.push(`fn get_key(item: &${typeName}) -> ${keySpec.rustKeyType} {\n`);
+            this.push(`${keySpec.rustKeyExpr}\n`);
+            this.push("}\n");
+            this.push(`fn key_extractor() -> &'static str {\n`);
+            this.push(`"${keySpec.keyExtractor}"\n`);
+            this.push("}\n");
+            this.push(`fn default_item() -> &'static ${typeName} {\n`);
+            this.push(`${typeName}::default_ref()\n`);
+            this.push("}\n");
+            this.push("}\n\n");
+        }
+        const structModulePath = this.moduleSpec.skirModule.path;
+        const structQualifiedName = struct.recordAncestors
+            .map((r) => r.name.text)
+            .join(".");
+        this.push(`impl ${typeName} {\n`);
+        this.push(`fn _adapter() -> &'static crate::skir_client::internal::StructAdapter<${typeName}> {\n`);
+        this.push(`static ADAPTER: std::sync::LazyLock<crate::skir_client::internal::StructAdapter<${typeName}>> =\n`);
+        this.push(`std::sync::LazyLock::new(|| {\n`);
+        this.push(`crate::skir_client::internal::StructAdapter::new(\n`);
+        this.push(`"${structModulePath}",\n`);
+        this.push(`"${structQualifiedName}",\n`);
+        this.push(`${toRustStringLiteral(docToCommentText(struct.record.doc))},\n`);
+        this.push(`|x: &${typeName}| &x._unrecognized,\n`);
+        this.push(`|x: &mut ${typeName}, u| x._unrecognized = u,\n`);
+        this.push(`)\n`);
+        this.push(`});\n`);
+        this.push(`&*ADAPTER\n`);
+        this.push("}\n");
+        this.push(`pub fn serializer() -> crate::skir_client::Serializer<${typeName}> {\n`);
+        this.push(`initialize_module_serializers();\n`);
+        this.push(`crate::skir_client::internal::struct_serializer_from_static(${typeName}::_adapter())\n`);
+        this.push("}\n");
+        this.push("}\n\n");
+    }
+    writeEnum(record) {
+        const { namer, typeSpeller } = this;
+        this.pushSeparator("enum ".concat(record.recordAncestors.map((r) => r.name.text).join(".")));
+        const typeName = getTypeName(record);
+        this.push(commentify(docToCommentText(record.record.doc)));
+        this.push(`#[derive(${namer.debug}, ${namer.clone}, ${namer.partialEq})]\n`);
+        this.push(`pub enum ${typeName} {\n`);
+        this.push(`Unknown(${namer.option}<crate::skir_client::UnrecognizedVariant<${typeName}>>),\n`);
+        const variantNamesNeedSuffix = doVariantNamesNeedSuffix(record.record.fields);
+        for (const variant of record.record.fields) {
+            const variantName = convertCase(variant.name.text, "UpperCamel").concat(variantNamesNeedSuffix ? (variant.type ? "Wrapper" : "Const") : "");
+            this.push(commentify(docToCommentText(variant.doc)));
+            if (variant.type) {
+                const variantType = variant.type;
+                let valueRustType = typeSpeller.getRustType(variantType);
+                if (doesWrapperVariantNeedBoxing(variantType)) {
+                    valueRustType = `${namer.box}<${valueRustType}>`;
+                }
+                this.push(`${variantName}(${valueRustType}),\n`);
+            }
+            else {
+                this.push(`${variantName},\n`);
+            }
+        }
+        this.push("}\n\n");
+        this.push(`impl ${namer.default} for ${typeName} {\n`);
+        this.push(`fn default() -> Self {\n`);
+        this.push(`${typeName}::Unknown(None)\n`);
+        this.push("}\n");
+        this.push("}\n\n");
+        if (this.keyedArrayContext.isEnumUsedAsKey(record.record)) {
+            // Write the _kind enum.
+            this.push(`#[derive(${namer.clone}, ${namer.copy}, ${namer.debug}, ${namer.eq}, ${namer.hash}, ${namer.partialEq})]\n`);
+            this.push(`pub enum ${typeName}_kind {\n`);
+            this.push("Unknown,\n");
+            for (const variant of record.record.fields) {
+                const variantName = convertCase(variant.name.text, "UpperCamel").concat(variantNamesNeedSuffix ? (variant.type ? "Wrapper" : "Const") : "");
+                this.push(`${variantName},\n`);
+            }
+            this.push("}\n\n");
+            // Write the kind() getter on the main enum.
+            this.push(`impl ${typeName} {\n`);
+            this.push(`pub fn kind(&self) -> ${typeName}_kind {\n`);
+            this.push(`match self {\n`);
+            this.push(`${typeName}::Unknown(_) => ${typeName}_kind::Unknown,\n`);
+            for (const variant of record.record.fields) {
+                const variantName = convertCase(variant.name.text, "UpperCamel").concat(variantNamesNeedSuffix ? (variant.type ? "Wrapper" : "Const") : "");
+                if (variant.type) {
+                    this.push(`${typeName}::${variantName}(_) => ${typeName}_kind::${variantName},\n`);
+                }
+                else {
+                    this.push(`${typeName}::${variantName} => ${typeName}_kind::${variantName},\n`);
+                }
+            }
+            this.push("}\n");
+            this.push("}\n");
+            this.push("}\n\n");
+        }
+        const enumModulePath = this.moduleSpec.skirModule.path;
+        const enumQualifiedName = record.recordAncestors
+            .map((r) => r.name.text)
+            .join(".");
+        this.push(`impl ${typeName} {\n`);
+        this.push(`fn _adapter() -> &'static crate::skir_client::internal::EnumAdapter<${typeName}> {\n`);
+        this.push(`static ADAPTER: std::sync::LazyLock<crate::skir_client::internal::EnumAdapter<${typeName}>> =\n`);
+        this.push(`std::sync::LazyLock::new(|| {\n`);
+        this.push(`crate::skir_client::internal::EnumAdapter::new(\n`);
+        this.push(`|x: &${typeName}| match x {\n`);
+        this.push(`${typeName}::Unknown(_) => 0,\n`);
+        let kindOrdinal = 1;
+        for (const variant of record.record.fields) {
+            const variantName = convertCase(variant.name.text, "UpperCamel").concat(variantNamesNeedSuffix ? (variant.type ? "Wrapper" : "Const") : "");
+            if (variant.type) {
+                this.push(`${typeName}::${variantName}(_) => ${kindOrdinal},\n`);
+            }
+            else {
+                this.push(`${typeName}::${variantName} => ${kindOrdinal},\n`);
+            }
+            kindOrdinal++;
+        }
+        this.push(`},\n`);
+        this.push(`|u| ${typeName}::Unknown(Some(u)),\n`);
+        this.push(`|x: &${typeName}| match x { ${typeName}::Unknown(Some(u)) => Some(u.as_ref()), _ => None },\n`);
+        this.push(`"${enumModulePath}",\n`);
+        this.push(`"${enumQualifiedName}",\n`);
+        this.push(`${toRustStringLiteral(docToCommentText(record.record.doc))},\n`);
+        this.push(`)\n`);
+        this.push(`});\n`);
+        this.push(`&*ADAPTER\n`);
+        this.push("}\n");
+        this.push(`pub fn serializer() -> crate::skir_client::Serializer<${typeName}> {\n`);
+        this.push(`initialize_module_serializers();\n`);
+        this.push(`crate::skir_client::internal::enum_serializer_from_static(${typeName}::_adapter())\n`);
+        this.push("}\n");
+        this.push("}\n\n");
+    }
+    writeInitializeModuleSerializersFn(records) {
+        const { typeSpeller } = this;
+        this.pushSeparator("initialize_module_serializers()");
+        this.push("fn initialize_module_serializers() {\n");
+        this.push("static INIT: std::sync::LazyLock<()> =\n");
+        this.push("std::sync::LazyLock::new(|| {\n");
+        for (const record of records) {
+            const typeName = getTypeName(record);
+            if (record.record.recordType === "struct") {
+                this.push("unsafe {\n");
+                this.push(`let a: *mut crate::skir_client::internal::StructAdapter<${typeName}> = ${typeName}::_adapter() as *const _ as *mut _;\n`);
+                for (const removedNumber of record.record.removedNumbers) {
+                    this.push(`(*a).add_removed_number(${removedNumber});\n`);
+                }
+                for (const field of record.record.fields) {
+                    const fieldName = toRustFieldName(field.name.text);
+                    let serializerExpr = typeSpeller.getSerializerExpression(field.type, "init");
+                    if (field.isRecursive === "hard") {
+                        serializerExpr = `crate::skir_client::internal::recursive_serializer(${serializerExpr})`;
+                    }
+                    const getter = field.isRecursive === "hard"
+                        ? `|x: &${typeName}| &x._${field.name.text}_rec`
+                        : `|x: &${typeName}| &x.${fieldName}`;
+                    const setter = field.isRecursive === "hard"
+                        ? `|x: &mut ${typeName}, v| x._${field.name.text}_rec = v`
+                        : `|x: &mut ${typeName}, v| x.${fieldName} = v`;
+                    this.push(`(*a).add_field("${field.name.text}", ${field.number}, ${serializerExpr}, ${toRustStringLiteral(docToCommentText(field.doc))}, ${getter}, ${setter});\n`);
+                }
+                this.push("(*a).finalize();\n");
+                this.push("}\n");
+            }
+            else {
+                const variantNamesNeedSuffix = doVariantNamesNeedSuffix(record.record.fields);
+                this.push("unsafe {\n");
+                this.push(`let a: *mut crate::skir_client::internal::EnumAdapter<${typeName}> = ${typeName}::_adapter() as *const _ as *mut _;\n`);
+                for (const removedNumber of record.record.removedNumbers) {
+                    this.push(`(*a).add_removed_number(${removedNumber});\n`);
+                }
+                let kindOrdinal = 1;
+                for (const variant of record.record.fields) {
+                    const variantName = convertCase(variant.name.text, "UpperCamel").concat(variantNamesNeedSuffix ? (variant.type ? "Wrapper" : "Const") : "");
+                    if (variant.type) {
+                        const serializerExpr = typeSpeller.getSerializerExpression(variant.type, "init");
+                        let wrapFn;
+                        let getValueFn;
+                        if (doesWrapperVariantNeedBoxing(variant.type)) {
+                            wrapFn = `|v| ${typeName}::${variantName}(Box::new(v))`;
+                            getValueFn = `|x| match x { ${typeName}::${variantName}(b) => b.as_ref(), _ => unreachable!() }`;
+                        }
+                        else {
+                            wrapFn = `|v| ${typeName}::${variantName}(v)`;
+                            getValueFn = `|x| match x { ${typeName}::${variantName}(v) => v, _ => unreachable!() }`;
+                        }
+                        this.push(`(*a).add_wrapper_variant("${variant.name.text}", ${variant.number}, ${kindOrdinal}, ${serializerExpr}, ${toRustStringLiteral(docToCommentText(variant.doc))}, ${wrapFn}, ${getValueFn});\n`);
+                    }
+                    else {
+                        this.push(`(*a).add_constant_variant("${variant.name.text}", ${variant.number}, ${kindOrdinal}, ${toRustStringLiteral(docToCommentText(variant.doc))}, ${typeName}::${variantName});\n`);
+                    }
+                    kindOrdinal++;
+                }
+                this.push("(*a).finalize();\n");
+                this.push("}\n");
+            }
+        }
+        this.push("});\n");
+        this.push("let _ = *INIT;\n");
+        this.push("}\n\n");
+    }
+    writeMethod(method) {
+        const { typeSpeller } = this;
+        const rustName = convertCase(method.name.text, "lower_underscore").concat("_method");
+        const requestRustType = typeSpeller.getRustType(method.requestType);
+        const responseRustType = typeSpeller.getRustType(method.responseType);
+        const requestSerializerExpr = typeSpeller.getSerializerExpression(method.requestType, null);
+        const responseSerializerExpr = typeSpeller.getSerializerExpression(method.responseType, null);
+        const nameStr = toRustStringLiteral(method.name.text);
+        const docStr = toRustStringLiteral(docToCommentText(method.doc));
+        this.push(commentify(docToCommentText(method.doc)));
+        this.push(`pub fn ${rustName}() -> &'static crate::skir_client::Method<${requestRustType}, ${responseRustType}> {\n`);
+        this.push(`static METHOD: std::sync::LazyLock<crate::skir_client::Method<${requestRustType}, ${responseRustType}>> = std::sync::LazyLock::new(|| {\n`);
+        this.push(`crate::skir_client::Method {\n`);
+        this.push(`name: ${nameStr}.to_string(),\n`);
+        this.push(`number: ${method.number}_i64,\n`);
+        this.push(`request_serializer: ${requestSerializerExpr},\n`);
+        this.push(`response_serializer: ${responseSerializerExpr},\n`);
+        this.push(`doc: ${docStr}.to_string(),\n`);
+        this.push("}\n");
+        this.push("});\n");
+        this.push("&*METHOD\n");
+        this.push("}\n\n");
+    }
+    writeConstant(constant) {
+        const { typeSpeller } = this;
+        const rustName = convertCase(constant.name.text, "lower_underscore").concat("_const");
+        const type = constant.type;
+        this.push(commentify(docToCommentText(constant.doc)));
+        const rustLiteral = tryGetRustLiteral(constant);
+        if (rustLiteral !== null) {
+            // This type can be represented as a real Rust const.
+            // String primitives must use &'static str because String is not
+            // const-eligible in Rust.
+            const constType = type.kind === "primitive" && type.primitive === "string"
+                ? "&'static str"
+                : typeSpeller.getRustType(type);
+            this.push(`pub const ${rustName}: ${constType} = ${rustLiteral};\n\n`);
+        }
+        else {
+            // Use LazyLock for lazy initialization from JSON.
+            const rustType = typeSpeller.getRustType(type);
+            const serializerExpr = typeSpeller.getSerializerExpression(type, null);
+            const jsonLiteral = toRustStringLiteral(JSON.stringify(constant.valueAsDenseJson));
+            this.push(`pub fn ${rustName}() -> &'static ${rustType} {\n`);
+            this.push(`static VALUE: std::sync::LazyLock<${rustType}> = std::sync::LazyLock::new(|| {\n`);
+            this.push(`${serializerExpr}.from_json(${jsonLiteral}, crate::skir_client::UnrecognizedValues::Drop).unwrap()\n`);
+            this.push("});\n");
+            this.push("&*VALUE\n");
+            this.push("}\n\n");
+        }
+    }
+    pushSeparator(header) {
+        this.push(`// ${"=".repeat(78)}\n`);
+        this.push(`// ${header}\n`);
+        this.push(`// ${"=".repeat(78)}\n\n`);
+    }
+    push(...code) {
+        this.code += code.join("");
+    }
+    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) +
+                (line.startsWith("*") ? " " : "");
+            result += `${indent}${line.trimEnd()}\n`;
+            if (line.startsWith("/") || line.startsWith("*")) {
+                // A comment.
+                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 doVariantNamesNeedSuffix(variants) {
+    const seenNames = new Set();
+    for (const variant of variants) {
+        const name = convertCase(variant.name.text, "UpperCamel");
+        if (isUpperCasedKeyword(name) || seenNames.has(name)) {
+            return true;
+        }
+        seenNames.add(name);
+    }
+    return false;
+}
+function doesWrapperVariantNeedBoxing(type) {
+    switch (type.kind) {
+        case "array":
+            return false;
+        case "optional":
+            return doesWrapperVariantNeedBoxing(type.other);
+        case "primitive":
+            return false;
+        case "record":
+            return true;
+    }
+}
+function toRustStringLiteral(input) {
+    const escaped = input
+        .replace(/\\/g, "\\\\") // Escape backslashes
+        .replace(/"/g, '\\"') // Escape double quotes
+        .replace(/\n/g, "\\n") // Escape newlines
+        .replace(/\r/g, "\\r") // Escape carriage returns
+        .replace(/\t/g, "\\t"); // Escape tabs
+    return `"${escaped}"`;
+}
+function tryGetRustLiteral(constant) {
+    const type = constant.type;
+    if (type.kind !== "primitive") {
+        return null;
+    }
+    const valueAsDenseJson = constant.valueAsDenseJson;
+    switch (type.primitive) {
+        case "bool":
+            return valueAsDenseJson ? "true" : "false";
+        case "int32":
+        case "int64":
+        case "hash64":
+        case "float32":
+        case "float64": {
+            const maybeQuoted = valueAsDenseJson.toString();
+            if (maybeQuoted === "Infinity" ||
+                maybeQuoted === "-Infinity" ||
+                maybeQuoted === "NaN") {
+                return null;
+            }
+            else {
+                return maybeQuoted.startsWith('"') && maybeQuoted.endsWith('"')
+                    ? maybeQuoted.slice(1, -1)
+                    : maybeQuoted;
+            }
+        }
+        case "string":
+            return toRustStringLiteral(valueAsDenseJson);
+    }
+    return null;
+}
+function commentify(textOrLines) {
+    const text = (typeof textOrLines === "string" ? textOrLines : textOrLines.join("\n"))
+        .trim()
+        .replace(/\n{3,}/g, "\n\n");
+    if (text.length <= 0) {
+        return "";
+    }
+    return text
+        .split("\n")
+        .map((line) => (line.length > 0 ? `/// ${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 RustCodeGenerator();
+//# sourceMappingURL=index.js.map