typespec-rust-emitter 0.1.0

package/src/emitter.ts

@@ -0,0 +1,685 @@
+import {
+  EmitContext,
+  emitFile,
+  resolvePath,
+  navigateProgram,
+  getDoc,
+  isArrayModelType,
+  isRecordModelType,
+  getFormat,
+  getPattern,
+  isErrorModel,
+  Type,
+  Model,
+  ModelProperty,
+  Enum,
+  Union,
+  Scalar,
+  Program,
+  Namespace,
+  IntrinsicType,
+  StringLiteral,
+  DecoratorContext,
+  getNamespaceFullName,
+} from "@typespec/compiler";
+
+export interface RustEmitterOptions {
+  moduleName?: string;
+}
+
+interface RustDeriveInfo {
+  derives: string[];
+}
+
+const rustDeriveKey = Symbol("rustDerive");
+
+export function $rustDerive(
+  context: DecoratorContext,
+  target: Type,
+  derive: string,
+) {
+  if (target.kind !== "Model") {
+    context.program.reportDiagnostic({
+      code: "rust-derive-invalid-target",
+      message: `@rustDerive can only be applied to models`,
+      severity: "error",
+      target: context.decoratorTarget,
+    });
+    return;
+  }
+
+  const model = target as Model;
+  const ns = model.namespace ? getNamespaceFullName(model.namespace) : "";
+
+  if (!ns.startsWith("TypeSpec")) {
+    const info = (model as any)[rustDeriveKey] as RustDeriveInfo | undefined;
+    if (info) {
+      if (!info.derives.includes(derive)) {
+        info.derives.push(derive);
+      }
+    } else {
+      (model as any)[rustDeriveKey] = { derives: [derive] };
+    }
+  }
+}
+
+export function $rustDerives(
+  context: DecoratorContext,
+  target: Type,
+  ...derives: string[]
+) {
+  for (const derive of derives) {
+    $rustDerive(context, target, derive);
+  }
+}
+
+const scalarToRust: Record<string, string> = {
+  string: "String",
+  int8: "i8",
+  int16: "i16",
+  int32: "i32",
+  int64: "i64",
+  uint8: "u8",
+  uint16: "u16",
+  uint32: "u32",
+  uint64: "u64",
+  float32: "f32",
+  float64: "f64",
+  boolean: "bool",
+  bytes: "Vec<u8>",
+  plainDate: "String",
+  plainTime: "String",
+  utcDateTime: "String",
+  offsetDateTime: "String",
+  duration: "String",
+  numeric: "f64",
+  integer: "i64",
+  float: "f64",
+  safeint: "i64",
+  decimal: "f64",
+  decimal128: "f64",
+  url: "String",
+};
+
+const formatToRust: Record<string, string> = {
+  uuid: "uuid::Uuid",
+  date: "chrono::NaiveDate",
+  time: "chrono::NaiveTime",
+  dateTime: "chrono::DateTime<chrono::Utc>",
+  "date-time": "chrono::DateTime<chrono::Utc>",
+};
+
+const typeSpecNamespaces = new Set([
+  "TypeSpec",
+  "@typespec/http",
+  "@typespec/rest",
+  "@typespec/openapi",
+  "@typespec/openapi3",
+  "@typespec/json-schema",
+]);
+
+function isStdLibNamespace(ns: Namespace | undefined): boolean {
+  if (!ns) return false;
+  const fullName = ns.name;
+  if (typeSpecNamespaces.has(fullName)) return true;
+  if (ns.namespace) return isStdLibNamespace(ns.namespace);
+  return false;
+}
+
+function isStdLibType(type: Type): boolean {
+  if ("namespace" in type) {
+    const ns = (type as Model | Enum | Union | Scalar).namespace;
+    if (isStdLibNamespace(ns as Namespace)) return true;
+  }
+  return false;
+}
+
+interface AnonymousStringLiteralUnion {
+  enumName: string;
+  variants: StringLiteral[];
+}
+
+function getRustTypeForProperty(
+  type: Type,
+  program: Program,
+  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
+): { type: string; isStringLiteral: boolean; stringLiteralValue?: string } {
+  const kind = type.kind as string;
+
+  if (kind === "Model") {
+    const model = type as Model;
+    if (isArrayModelType(model) && model.indexer?.value) {
+      const element = getRustTypeForProperty(
+        model.indexer.value,
+        program,
+        anonymousEnums,
+      );
+      return { type: `Vec<${element.type}>`, isStringLiteral: false };
+    }
+    if (isRecordModelType(model) && model.indexer?.value) {
+      const value = getRustTypeForProperty(
+        model.indexer.value,
+        program,
+        anonymousEnums,
+      );
+      return {
+        type: `std::collections::HashMap<String, ${value.type}>`,
+        isStringLiteral: false,
+      };
+    }
+    return { type: toPascalCase(model.name), isStringLiteral: false };
+  }
+
+  if (kind === "ModelProperty") {
+    return getRustTypeForProperty(
+      (type as ModelProperty).type,
+      program,
+      anonymousEnums,
+    );
+  }
+
+  if (kind === "Enum") {
+    return { type: toPascalCase((type as Enum).name), isStringLiteral: false };
+  }
+
+  if (kind === "Union") {
+    const unionType = type as Union;
+    const variants = Array.from(unionType.variants.values());
+    const allStringLiterals = variants.every((v) => v.type.kind === "String");
+
+    if (allStringLiterals) {
+      if (unionType.name) {
+        return {
+          type: toPascalCase(unionType.name),
+          isStringLiteral: false,
+        };
+      }
+      const values = variants.map((v) => (v.type as StringLiteral).value);
+      const enumName = `Enum_${values.slice(0, 2).join("_")}_${values.length}`;
+      if (!anonymousEnums.has(enumName)) {
+        anonymousEnums.set(enumName, {
+          enumName,
+          variants: variants.map((v) => v.type as StringLiteral),
+        });
+      }
+      return { type: enumName, isStringLiteral: false };
+    }
+
+    const nonNullVariants = variants.filter((v) => {
+      const vt = v.type;
+      if ((vt.kind as string) === "Null") return false;
+      if (
+        (vt.kind as string) === "Intrinsic" &&
+        (vt as IntrinsicType).name === "null"
+      )
+        return false;
+      return true;
+    });
+
+    if (
+      nonNullVariants.length === 1 &&
+      (variants.length === 2 ||
+        variants.some((v) => {
+          const vt = v.type;
+          return (
+            (vt.kind as string) === "Null" ||
+            ((vt.kind as string) === "Intrinsic" &&
+              (vt as IntrinsicType).name === "null")
+          );
+        }))
+    ) {
+      const vt = getRustTypeForProperty(
+        nonNullVariants[0].type,
+        program,
+        anonymousEnums,
+      );
+      return { type: `Option<${vt.type}>`, isStringLiteral: false };
+    }
+
+    const variantStrings: string[] = [];
+    for (const v of variants) {
+      const vt = v.type;
+      if ((vt.kind as string) === "Null") continue;
+      if (
+        (vt.kind as string) === "Intrinsic" &&
+        (vt as IntrinsicType).name === "null"
+      )
+        continue;
+      const rustVt = getRustTypeForProperty(vt, program, anonymousEnums);
+      variantStrings.push(rustVt.type);
+    }
+    const uniqueTypes = [...new Set(variantStrings)];
+    const resultType =
+      uniqueTypes.length === 1
+        ? uniqueTypes[0]
+        : `(${uniqueTypes.join(" | ")})`;
+    return { type: resultType, isStringLiteral: false };
+  }
+
+  if (kind === "Scalar") {
+    const scalar = type as Scalar;
+    const format = getFormat(program, scalar);
+    const pattern = getPattern(program, scalar);
+
+    if (format && formatToRust[format] && !pattern) {
+      return { type: formatToRust[format], isStringLiteral: false };
+    }
+    if (pattern) {
+      return { type: toPascalCase(scalar.name), isStringLiteral: false };
+    }
+    return {
+      type: scalarToRust[scalar.name] ?? scalar.name,
+      isStringLiteral: false,
+    };
+  }
+
+  if (kind === "Intrinsic") {
+    const intrinsic = type as IntrinsicType;
+    const format = getFormat(program, type);
+    if (format && formatToRust[format]) {
+      return { type: formatToRust[format], isStringLiteral: false };
+    }
+    return {
+      type: scalarToRust[intrinsic.name] ?? "serde_json::Value",
+      isStringLiteral: false,
+    };
+  }
+
+  if (kind === "String") {
+    return { type: "String", isStringLiteral: false };
+  }
+
+  if (kind === "StringLiteral") {
+    return {
+      type: "String",
+      isStringLiteral: true,
+      stringLiteralValue: (type as StringLiteral).value,
+    };
+  }
+
+  if (kind === "Boolean" || kind === "BooleanLiteral") {
+    return { type: "bool", isStringLiteral: false };
+  }
+
+  if (kind === "Number" || kind === "NumericLiteral") {
+    return { type: "f64", isStringLiteral: false };
+  }
+
+  return { type: "serde_json::Value", isStringLiteral: false };
+}
+
+function toRustIdent(name: string): string {
+  const snakeCase = name.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+  const result = snakeCase.replace(/[^a-z0-9_]/g, "_");
+  if (/^[0-9]/.test(result)) {
+    return "_" + result;
+  }
+  return result;
+}
+
+function toPascalCase(name: string): string {
+  if (/^[^a-z]+$/.test(name)) {
+    return name;
+  }
+  if (/[-_]/.test(name)) {
+    return name
+      .split(/[-_]/)
+      .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+      .join("");
+  }
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+function toRustVariantName(name: string): string {
+  return toPascalCase(name);
+}
+
+function formatDoc(doc: string | undefined): string {
+  if (!doc) return "";
+  return doc
+    .split("\n")
+    .map((line) => `/// ${line.trim()}`)
+    .join("\n");
+}
+
+function emitStringLiteralUnion(union: Union): string {
+  const parts: string[] = [];
+  const name = toPascalCase(union.name ?? "Value");
+  const variants = Array.from(union.variants.values());
+
+  parts.push(
+    `#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]\npub enum ${name} {`,
+  );
+
+  for (const variant of variants) {
+    const literalType = variant.type as StringLiteral;
+    const variantName = toRustVariantName(literalType.value);
+    const serdeValue = literalType.value;
+    parts.push(`  #[serde(rename = "${serdeValue}")]`);
+    parts.push(`  ${variantName},`);
+  }
+
+  parts.push("}");
+  const defaultVariant = toRustVariantName(
+    variants[0]?.type ? (variants[0].type as StringLiteral).value : "",
+  );
+  parts.push(
+    `\n\nimpl Default for ${name} {\n  fn default() -> Self {\n    ${name}::${defaultVariant}\n  }\n}`,
+  );
+  return parts.join("\n");
+}
+
+function emitModel(
+  model: Model,
+  program: Program,
+  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
+): string {
+  const parts: string[] = [];
+  const name = toPascalCase(model.name);
+  const allProps = getAllProperties(model, program);
+  const isError = isErrorModel(program, model);
+
+  const deriveAttrs = [
+    "Debug",
+    "Clone",
+    "serde::Serialize",
+    "serde::Deserialize",
+  ];
+
+  const customDerives = (model as any)[rustDeriveKey] as
+    | RustDeriveInfo
+    | undefined;
+  if (customDerives) {
+    deriveAttrs.push(...customDerives.derives);
+  }
+
+  if (isError) {
+    deriveAttrs.push("thiserror::Error");
+  }
+
+  parts.push(`#[derive(${deriveAttrs.join(", ")})]`);
+
+  if (isError && allProps.size > 0) {
+    parts.push('#[error("{code}: {message}")]');
+  }
+
+  parts.push(`pub struct ${name}`);
+
+  if (allProps.size > 0) {
+    parts.push(" {");
+    for (const [propName, prop] of allProps) {
+      const doc = getDoc(program, prop);
+      const { type: rustType } = getRustTypeForProperty(
+        prop.type,
+        program,
+        anonymousEnums,
+      );
+      const optional = prop.optional ? true : false;
+      const fieldName = toRustIdent(propName);
+      const serdeRename =
+        propName !== fieldName ? `#[serde(rename = "${propName}")]` : "";
+
+      if (doc) {
+        parts.push(`\n  ${formatDoc(doc)}`);
+      }
+      if (serdeRename) {
+        parts.push(`  ${serdeRename}`);
+      }
+      if (optional) {
+        parts.push(`  #[serde(skip_serializing_if = "Option::is_none")]`);
+      }
+      parts.push(
+        `  pub ${fieldName}: ${optional ? `Option<${rustType}>` : rustType},`,
+      );
+    }
+    parts.push("}");
+  } else {
+    parts.push("(());");
+  }
+
+  return parts.join("\n");
+}
+
+function getAllProperties(
+  model: Model,
+  _program: Program,
+): Map<string, ModelProperty> {
+  const props = new Map<string, ModelProperty>();
+
+  if (model.baseModel) {
+    const baseProps = getAllProperties(model.baseModel, _program);
+    for (const [key, value] of baseProps) {
+      props.set(key, value);
+    }
+  }
+
+  for (const [key, value] of model.properties) {
+    props.set(key, value);
+  }
+
+  return props;
+}
+
+function emitEnum(enumType: Enum): string {
+  const parts: string[] = [];
+  const name = toPascalCase(enumType.name);
+  const members = Array.from(enumType.members.values());
+  const isString = members.every(
+    (m) => m.value === undefined || typeof m.value === "string",
+  );
+
+  if (isString) {
+    parts.push(
+      `#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]\npub enum ${name} {`,
+    );
+    for (const member of members) {
+      const variantName = toRustVariantName(member.name);
+      const serdeValue = member.value ?? member.name;
+      parts.push(`  #[serde(rename = "${serdeValue}")]`);
+      parts.push(`  ${variantName},`);
+    }
+  } else {
+    parts.push(
+      `#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]\npub enum ${name} {`,
+    );
+    for (const member of members) {
+      const variantName = toRustVariantName(member.name);
+      const enumValue = member.value ?? 0;
+      parts.push(`  ${variantName} = ${enumValue},`);
+    }
+  }
+  parts.push("}");
+  const defaultVariant = toRustVariantName(members[0]?.name ?? "");
+  parts.push(
+    `\n\nimpl Default for ${name} {\n  fn default() -> Self {\n    ${name}::${defaultVariant}\n  }\n}`,
+  );
+  return parts.join("\n");
+}
+
+function emitUnion(union: Union, program: Program): string {
+  const parts: string[] = [];
+  const name = toPascalCase(union.name ?? "Union");
+
+  const variants = Array.from(union.variants.values());
+  if (variants.length === 0) {
+    parts.push(
+      `#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]\npub enum ${name} {}\nimpl ${name} {\n  pub fn new() -> Self { unreachable!() }\n}`,
+    );
+    return parts.join("\n");
+  }
+
+  parts.push(
+    `#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]\n#[serde(untagged)]\npub enum ${name} {`,
+  );
+  for (let i = 0; i < variants.length; i++) {
+    const variant = variants[i];
+    const variantName = `Variant${i + 1}`;
+    const { type: rustType } = getRustTypeForProperty(
+      variant.type,
+      program,
+      new Map(),
+    );
+    parts.push(`  ${variantName}(${rustType}),`);
+  }
+  parts.push("}");
+
+  return parts.join("\n");
+}
+
+function emitScalar(
+  scalar: Scalar,
+  program: Program,
+): { typeDef: string; impls: string[] } {
+  const format = getFormat(program, scalar);
+  const pattern = getPattern(program, scalar);
+  const structName = toPascalCase(scalar.name);
+  const impls: string[] = [];
+
+  if (format && formatToRust[format]) {
+    return {
+      typeDef: `pub type ${structName} = ${formatToRust[format]};`,
+      impls: [],
+    };
+  }
+
+  if (pattern) {
+    const rustType = scalarToRust[scalar.name] ?? "String";
+    impls.push(
+      `\nimpl TryFrom<String> for ${structName} {\n  type Error = String;\n\n  fn try_from(value: String) -> Result<Self, Self::Error> {\n    let re = regex::Regex::new(r"${pattern}").unwrap();\n    if re.is_match(&value) { Ok(Self(value)) } else { Err(format!("Invalid value: {}", value)) }\n  }\n}`,
+    );
+    impls.push(
+      `\nimpl Default for ${structName} {\n  fn default() -> Self {\n    Self(String::new())\n  }\n}`,
+    );
+
+    return {
+      typeDef: `#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]\npub struct ${structName}(pub ${rustType});`,
+      impls,
+    };
+  }
+
+  const rustType = scalarToRust[scalar.name] ?? "serde_json::Value";
+  return {
+    typeDef: `pub type ${structName} = ${rustType};`,
+    impls: [],
+  };
+}
+
+export async function $onEmit(
+  context: EmitContext<RustEmitterOptions>,
+  _options?: RustEmitterOptions,
+) {
+  const content: string[] = [];
+
+  const models: Model[] = [];
+  const enums: Enum[] = [];
+  const unions: Union[] = [];
+  const scalars: Scalar[] = [];
+  const stringLiteralUnions: Union[] = [];
+  const anonymousEnums = new Map<string, AnonymousStringLiteralUnion>();
+
+  const seenTypes = new Set<string>();
+
+  navigateProgram(context.program, {
+    model(model: Model) {
+      if (model.name && !seenTypes.has(model.name) && !isStdLibType(model)) {
+        seenTypes.add(model.name);
+        models.push(model);
+      }
+    },
+    enum(enumType: Enum) {
+      if (
+        enumType.name &&
+        !seenTypes.has(enumType.name) &&
+        !isStdLibType(enumType)
+      ) {
+        seenTypes.add(enumType.name);
+        enums.push(enumType);
+      }
+    },
+    union(unionType: Union) {
+      if (
+        unionType.name &&
+        !seenTypes.has(unionType.name) &&
+        !isStdLibType(unionType)
+      ) {
+        seenTypes.add(unionType.name);
+
+        const variants = Array.from(unionType.variants.values());
+        const allStringLiterals = variants.every(
+          (v) => (v.type.kind as string) === "String",
+        );
+
+        if (allStringLiterals) {
+          stringLiteralUnions.push(unionType);
+        } else {
+          unions.push(unionType);
+        }
+      }
+    },
+    scalar(scalarType: Scalar) {
+      if (
+        scalarType.name &&
+        !seenTypes.has(scalarType.name) &&
+        !isStdLibType(scalarType)
+      ) {
+        seenTypes.add(scalarType.name);
+        scalars.push(scalarType);
+      }
+    },
+  });
+
+  for (const model of models) {
+    content.push(emitModel(model, context.program, anonymousEnums));
+    content.push("");
+  }
+
+  for (const [enumName, anonEnum] of anonymousEnums) {
+    const parts: string[] = [];
+    parts.push(
+      `#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]\npub enum ${enumName} {`,
+    );
+    for (const literal of anonEnum.variants) {
+      const variantName = toRustVariantName(literal.value);
+      parts.push(`  #[serde(rename = "${literal.value}")]`);
+      parts.push(`  ${variantName},`);
+    }
+    parts.push("}");
+    const defaultVariant = toRustVariantName(anonEnum.variants[0]?.value ?? "");
+    parts.push(
+      `\n\nimpl Default for ${enumName} {\n  fn default() -> Self {\n    ${enumName}::${defaultVariant}\n  }\n}`,
+    );
+    content.push(parts.join("\n"));
+    content.push("");
+  }
+
+  for (const stringLiteralUnion of stringLiteralUnions) {
+    content.push(emitStringLiteralUnion(stringLiteralUnion));
+    content.push("");
+  }
+
+  for (const enumType of enums) {
+    content.push(emitEnum(enumType));
+    content.push("");
+  }
+
+  for (const unionType of unions) {
+    content.push(emitUnion(unionType, context.program));
+    content.push("");
+  }
+
+  for (const scalarType of scalars) {
+    const { typeDef, impls } = emitScalar(scalarType, context.program);
+    content.push(typeDef);
+    for (const impl of impls) {
+      content.push(impl);
+    }
+    content.push("");
+  }
+
+  const outputContent = content.join("\n");
+
+  await emitFile(context.program, {
+    path: resolvePath(context.emitterOutputDir, "types.rs"),
+    content: outputContent,
+  });
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { $onEmit } from "./emitter.js";
+export { $rustDerive, $rustDerives } from "./emitter.js";
+export { $lib } from "./lib.js";

package/src/lib.ts

@@ -0,0 +1,8 @@
+import { createTypeSpecLibrary } from "@typespec/compiler";
+
+export const $lib = createTypeSpecLibrary({
+  name: "typespec-emitter",
+  diagnostics: {},
+});
+
+export const { reportDiagnostic, createDiagnostic } = $lib;

package/src/lib.tsp

@@ -0,0 +1,6 @@
+import "../dist/src/emitter.js";
+
+using TypeSpec.Reflection;
+
+extern dec rustDerive(target: Model, derive: valueof string);
+extern dec rustDerives(target: Model, ...derives: valueof string[]);

package/src/testing/index.ts

@@ -0,0 +1,8 @@
+import { resolvePath } from "@typespec/compiler";
+import { createTestLibrary, TypeSpecTestLibrary } from "@typespec/compiler/testing";
+import { fileURLToPath } from "url";
+
+export const TypespecEmitterTestLibrary: TypeSpecTestLibrary = createTestLibrary({
+  name: "typespec-emitter",
+  packageRoot: resolvePath(fileURLToPath(import.meta.url), "../../../../"),
+});