skir-rust-gen 0.1.0

package/src/index.ts

@@ -0,0 +1,781 @@
+import {
+  type CodeGenerator,
+  type Constant,
+  convertCase,
+  type Doc,
+  type Field,
+  type Method,
+  type RecordKey,
+  type RecordLocation,
+  type ResolvedType,
+} 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, RustModuleSpec } from "./rust_module_spec.js";
+import { skirDefaultIsRustDefault, TypeSpeller } from "./type_speller.js";
+
+const Config = z.strictObject({});
+
+type Config = z.infer<typeof Config>;
+
+class RustCodeGenerator implements CodeGenerator<Config> {
+  readonly id = "skir-rust-gen";
+  readonly configType = Config;
+
+  generateCode(input: CodeGenerator.Input<Config>): CodeGenerator.Output {
+    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(
+    private readonly moduleSpec: RustModuleSpec,
+    recordMap: ReadonlyMap<RecordKey, RecordLocation>,
+    private readonly keyedArrayContext: KeyedArrayContext,
+    private readonly config: Config,
+  ) {
+    this.namer = new Namer(moduleSpec.skirModule);
+    this.typeSpeller = new TypeSpeller(recordMap, this.namer);
+  }
+
+  generate(): string {
+    // 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();
+  }
+
+  private writeStruct(struct: RecordLocation): void {
+    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");
+  }
+
+  private writeEnum(record: RecordLocation): void {
+    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");
+  }
+
+  private writeInitializeModuleSerializersFn(
+    records: readonly RecordLocation[],
+  ): void {
+    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: string;
+            let getValueFn: string;
+            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");
+  }
+
+  private writeMethod(method: Method): void {
+    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");
+  }
+
+  private writeConstant(constant: Constant): void {
+    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");
+    }
+  }
+
+  private pushSeparator(header: string): void {
+    this.push(`// ${"=".repeat(78)}\n`);
+    this.push(`// ${header}\n`);
+    this.push(`// ${"=".repeat(78)}\n\n`);
+  }
+
+  private push(...code: string[]): void {
+    this.code += code.join("");
+  }
+
+  private joinLinesAndFixFormatting(): string {
+    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: Array<"{" | "(" | "[" | "<" | ":" | "."> = [];
+    // Returns the last element in `contextStack`.
+    const peakTop = (): string => contextStack.at(-1)!;
+    const getMatchingLeftBracket = (r: "}" | ")" | "]" | ">"): string => {
+      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")
+    );
+  }
+
+  private readonly namer: Namer;
+  private readonly typeSpeller: TypeSpeller;
+  private code = "";
+}
+
+function doVariantNamesNeedSuffix(variants: readonly Field[]): boolean {
+  const seenNames = new Set<string>();
+  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: ResolvedType): boolean {
+  switch (type.kind) {
+    case "array":
+      return false;
+    case "optional":
+      return doesWrapperVariantNeedBoxing(type.other);
+    case "primitive":
+      return false;
+    case "record":
+      return true;
+  }
+}
+
+function toRustStringLiteral(input: string): string {
+  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: Constant): string | null {
+  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 as string);
+  }
+  return null;
+}
+
+function commentify(textOrLines: string | readonly string[]): string {
+  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: Doc): string {
+  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();