skir-dart-gen 0.0.1

package/src/naming.ts

@@ -0,0 +1,163 @@
+import {
+  Constant,
+  Field,
+  Module,
+  RecordLocation,
+  convertCase,
+} from "skir-internal";
+
+export function structFieldToDartName(field: Field | string): string {
+  const skirName = typeof field === "string" ? field : field.name.text;
+  const convertCaseResult = convertCase(skirName, "lowerCamel");
+  return DART_KEYWORDS.has(convertCaseResult) ||
+    DART_OBJECT_SYMBOLS.has(convertCaseResult) ||
+    GENERATED_STRUCT_SYMBOLS.has(convertCaseResult) ||
+    skirName.startsWith("mutable_")
+    ? convertCaseResult + "_"
+    : convertCaseResult;
+}
+
+export function enumFieldToDartName(field: Field): string {
+  const skirName = field.name.text;
+  const convertCaseResult = convertCase(skirName, "lowerCamel");
+  return DART_KEYWORDS.has(convertCaseResult) ||
+    DART_OBJECT_SYMBOLS.has(convertCaseResult) ||
+    GENERATED_ENUM_SYMBOLS.has(convertCaseResult) ||
+    skirName.startsWith("wrap_") ||
+    skirName.startsWith("create_")
+    ? convertCaseResult + "_"
+    : convertCaseResult;
+}
+
+export function toLowerCamel(field: Field): string {
+  const skirName = field.name.text;
+  return convertCase(skirName, "lowerCamel");
+}
+
+export function toUpperCamel(field: Field): string {
+  const skirName = field.name.text;
+  return convertCase(skirName, "UpperCamel");
+}
+
+export function toTopLevelConstantName(constant: Constant): string {
+  const skirName = constant.name.text;
+  const convertCaseResult = convertCase(skirName, "lowerCamel");
+  return DART_KEYWORDS.has(convertCaseResult) || skirName.endsWith("_METHOD")
+    ? convertCaseResult + "_"
+    : convertCaseResult;
+}
+
+/** Returns the name of the frozen Dart class for the given record. */
+export function getClassName(
+  record: RecordLocation,
+  origin: {
+    origin: Module;
+  },
+): string {
+  const { recordAncestors } = record;
+  const parts: string[] = [];
+  for (let i = 0; i < recordAncestors.length; ++i) {
+    const record = recordAncestors[i]!;
+    parts.push(record.name.text);
+  }
+
+  const name = parts.join("_");
+
+  if (origin.origin.path === record.modulePath) {
+    return name;
+  } else {
+    const alias = getModuleAlias(record.modulePath);
+    return `${alias}.${name}`;
+  }
+}
+
+export function getModuleAlias(modulePath: string): string {
+  return "_lib_" + modulePath.replace(/\.skir$/, "").replace("/", "_");
+}
+
+const DART_KEYWORDS: ReadonlySet<string> = new Set([
+  "abstract",
+  "as",
+  "assert",
+  "async",
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "covariant",
+  "default",
+  "deferred",
+  "do",
+  "dynamic",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "extension",
+  "external",
+  "factory",
+  "false",
+  "final",
+  "finally",
+  "for",
+  "Function",
+  "get",
+  "hide",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "interface",
+  "is",
+  "late",
+  "library",
+  "mixin",
+  "new",
+  "null",
+  "on",
+  "operator",
+  "part",
+  "required",
+  "rethrow",
+  "return",
+  "set",
+  "show",
+  "static",
+  "super",
+  "switch",
+  "sync",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typedef",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield",
+]);
+
+const DART_OBJECT_SYMBOLS: ReadonlySet<string> = new Set([
+  "hashCode",
+  "noSuchMethod",
+  "runtimeType",
+  "toString",
+]);
+
+const GENERATED_STRUCT_SYMBOLS: ReadonlySet<string> = new Set([
+  "defaultInstance",
+  "mutable",
+  "serializer",
+  "toFrozen",
+  "toMutable",
+]);
+
+const GENERATED_ENUM_SYMBOLS: ReadonlySet<string> = new Set([
+  "isUnknown",
+  "kind",
+  "serializer",
+]);

package/src/type_speller.ts

@@ -0,0 +1,232 @@
+import type {
+  Module,
+  RecordKey,
+  RecordLocation,
+  ResolvedType,
+} from "skir-internal";
+import { getClassName, structFieldToDartName } from "./naming.js";
+
+export type TypeFlavor =
+  | "initializer"
+  | "frozen"
+  | "maybe-mutable"
+  | "mutable"
+  | "kind";
+
+/**
+ * Transforms a type found in a `.skir` file into a Dart type.
+ *
+ * The flavors are:
+ *   · initializer
+ *       The value can be passed by parameter to the constructor of a frozen class.
+ *   · frozen:
+ *       The type is deeply immutable. All the fields of a frozen class are also
+ *       frozen.
+ *   · maybe-mutable:
+ *       Type union of the frozen type and the mutable type. All the fields of a
+ *       mutable class are maybe-mutable.
+ *   · mutable:
+ *       A mutable value. Not all types found in `.skir` files support this, e.g.
+ *       strings and numbers are always immutable.
+ */
+export class TypeSpeller {
+  constructor(
+    readonly recordMap: ReadonlyMap<RecordKey, RecordLocation>,
+    private readonly origin: Module,
+  ) {}
+
+  getDartType(
+    type: ResolvedType,
+    flavor: "initializer" | "frozen" | "mutable",
+    allRecordsFrozen?: undefined,
+  ): string;
+
+  getDartType(
+    type: ResolvedType,
+    flavor: TypeFlavor,
+    // Only matters if mode is "maybe-mutable"
+    allRecordsFrozen: boolean | undefined,
+  ): string;
+
+  getDartType(
+    type: ResolvedType,
+    flavor: TypeFlavor,
+    // Only matters if mode is "maybe-mutable"
+    allRecordsFrozen: boolean | undefined,
+  ): string {
+    switch (type.kind) {
+      case "record": {
+        const recordLocation = this.recordMap.get(type.key)!;
+        const record = recordLocation.record;
+        const className = this.getClassName(recordLocation);
+        if (record.recordType === "struct") {
+          if (flavor === "frozen" || allRecordsFrozen) {
+            return className;
+          } else if (flavor === "maybe-mutable" || flavor === "initializer") {
+            return allRecordsFrozen ? className : `${className}_orMutable`;
+          } else if (flavor === "mutable") {
+            return `${className}_mutable`;
+          } else {
+            const _: "kind" = flavor;
+            throw TypeError();
+          }
+        }
+        // An enum.
+        const _: "enum" = record.recordType;
+        if (
+          flavor === "initializer" ||
+          flavor === "frozen" ||
+          flavor === "maybe-mutable" ||
+          flavor === "mutable"
+        ) {
+          return className;
+        } else if (flavor === "kind") {
+          return `${className}_kind`;
+        } else {
+          const _: never = flavor;
+          throw TypeError();
+        }
+      }
+      case "array": {
+        if (flavor === "initializer") {
+          const itemType = this.getDartType(
+            type.item,
+            "maybe-mutable",
+            allRecordsFrozen,
+          );
+          return `_core.Iterable<${itemType}>`;
+        } else if (flavor === "frozen") {
+          const itemType = this.getDartType(
+            type.item,
+            "frozen",
+            allRecordsFrozen,
+          );
+          if (type.key) {
+            const { keyType } = type.key;
+            let dartKeyType = this.getDartType(keyType, "frozen");
+            if (keyType.kind === "record") {
+              dartKeyType += "_kind";
+            }
+            return `_skir.KeyedIterable<${itemType}, ${dartKeyType}>`;
+          } else {
+            return `_core.Iterable<${itemType}>`;
+          }
+        } else if (flavor === "maybe-mutable") {
+          const itemType = this.getDartType(
+            type.item,
+            "maybe-mutable",
+            allRecordsFrozen,
+          );
+          return `_core.Iterable<${itemType}>`;
+        } else if (flavor === "mutable") {
+          const itemType = this.getDartType(
+            type.item,
+            "maybe-mutable",
+            allRecordsFrozen,
+          );
+          return `_core.List<${itemType}>`;
+        } else {
+          const _: "kind" = flavor;
+          throw TypeError();
+        }
+      }
+      case "optional": {
+        const otherType = this.getDartType(
+          type.other,
+          flavor,
+          allRecordsFrozen,
+        );
+        return `${otherType}?`;
+      }
+      case "primitive": {
+        const { primitive } = type;
+        switch (primitive) {
+          case "bool":
+            return "_core.bool";
+          case "int32":
+          case "int64":
+            return "_core.int";
+          case "uint64":
+            return "_core.BigInt";
+          case "float32":
+          case "float64":
+            return "_core.double";
+          case "timestamp":
+            return "_core.DateTime";
+          case "string":
+            return "_core.String";
+          case "bytes":
+            return "_skir.ByteString";
+        }
+      }
+    }
+  }
+
+  getClassName(recordOrKey: RecordKey | RecordLocation): string {
+    const record =
+      typeof recordOrKey === "string"
+        ? this.recordMap.get(recordOrKey)!
+        : recordOrKey;
+    return getClassName(record, { origin: this.origin });
+  }
+
+  getSerializerExpression(type: ResolvedType): string {
+    switch (type.kind) {
+      case "primitive": {
+        switch (type.primitive) {
+          case "bool":
+            return "_skir.Serializers.bool";
+          case "int32":
+            return "_skir.Serializers.int32";
+          case "int64":
+            return "_skir.Serializers.int64";
+          case "uint64":
+            return "_skir.Serializers.uint64";
+          case "float32":
+            return "_skir.Serializers.float32";
+          case "float64":
+            return "_skir.Serializers.float64";
+          case "timestamp":
+            return "_skir.Serializers.timestamp";
+          case "string":
+            return "_skir.Serializers.string";
+          case "bytes":
+            return "_skir.Serializers.bytes";
+        }
+        const _: never = type.primitive;
+        throw TypeError();
+      }
+      case "array": {
+        if (type.key) {
+          const keyChain = type.key.path.map((p) => p.name.text).join(".");
+          const path = type.key.path
+            .map((f) => structFieldToDartName(f.name.text))
+            .join(".");
+          const itemType = this.getDartType(type.item, "frozen");
+          return (
+            "_skir.Serializers.keyedIterable(\n" +
+            `${this.getSerializerExpression(type.item)},\n` +
+            `(${itemType} it) => it.${path},\n` +
+            `internal__getKeySpec: "${keyChain}",\n)`
+          );
+        } else {
+          return (
+            "_skir.Serializers.iterable(\n" +
+            this.getSerializerExpression(type.item) +
+            ",\n)"
+          );
+        }
+      }
+      case "optional": {
+        return (
+          `_skir.Serializers.optional(\n` +
+          this.getSerializerExpression(type.other) +
+          `,\n)`
+        );
+      }
+      case "record": {
+        return this.getClassName(type.key) + ".serializer";
+      }
+    }
+  }
+}