skir-java-gen 0.0.2

package/src/naming.ts

@@ -0,0 +1,161 @@
+import { Field, RecordLocation, convertCase } from "skir-internal";
+
+export interface ClassName {
+  /** The name right after the 'class' keyword. */
+  name: string;
+  /**
+   * Fully qualified class name.
+   * Examples: 'skirout.Foo', 'skirout.Foo.Bar'
+   */
+  qualifiedName: string;
+}
+
+export class Namer {
+  private readonly genPackageFirstName: string;
+
+  constructor(private readonly packagePrefix: string) {
+    if (packagePrefix.length <= 0) {
+      this.genPackageFirstName = "skirout";
+    } else {
+      this.genPackageFirstName = packagePrefix.split(".")[0]!;
+    }
+  }
+
+  structFieldToJavaName(field: Field | string): string {
+    const skirName = typeof field === "string" ? field : field.name.text;
+    const lowerCamel = convertCase(skirName, "lowerCamel");
+    const nameConflict =
+      JAVA_HARD_KEYWORDS.has(lowerCamel) ||
+      TOP_LEVEL_PACKAGE_NAMES.has(lowerCamel) ||
+      JAVA_OBJECT_SYMBOLS.has(lowerCamel) ||
+      GENERATED_STRUCT_SYMBOLS.has(lowerCamel) ||
+      lowerCamel === this.genPackageFirstName;
+    return nameConflict ? lowerCamel + "_" : lowerCamel;
+  }
+
+  /** Returns the name of the frozen Java class for the given record. */
+  getClassName(record: RecordLocation): ClassName {
+    const { recordAncestors } = record;
+    const parts: string[] = [];
+    const seenNames = new Set<string>();
+    for (let i = 0; i < recordAncestors.length; ++i) {
+      const record = recordAncestors[i]!;
+      let name = record.name.text;
+      if (
+        name === "Kind" ||
+        name === "Builder" ||
+        /[^a-z]Wrapper$/.test(name) ||
+        (i === 0 && (name === "Constants" || name === "Methods"))
+      ) {
+        name += "_";
+      }
+      while (seenNames.has(name)) {
+        name += "_";
+      }
+      seenNames.add(name);
+      parts.push(name);
+    }
+
+    const name = parts.at(-1)!;
+
+    const path = record.modulePath;
+    const importPath = path.replace(/\.skir$/, "").replace("/", ".");
+    const qualifiedName = `${this.packagePrefix}skirout.${importPath}.${parts.join(".")}`;
+
+    return { name, qualifiedName };
+  }
+}
+
+// TODO: update
+const JAVA_HARD_KEYWORDS: ReadonlySet<string> = new Set([
+  "abstract",
+  "assert",
+  "boolean",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "class",
+  "const",
+  "continue",
+  "default",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "exports",
+  "extends",
+  "false",
+  "final",
+  "finally",
+  "float",
+  "for",
+  "goto",
+  "if",
+  "implements",
+  "import",
+  "instanceof",
+  "int",
+  "interface",
+  "long",
+  "module",
+  "native",
+  "new",
+  "null",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "short",
+  "static",
+  "strictfp",
+  "super",
+  "switch",
+  "synchronized",
+  "this",
+  "throw",
+  "throws",
+  "transient",
+  "true",
+  "try",
+  "void",
+  "volatile",
+  "while",
+  "with",
+  "yield",
+]);
+
+const TOP_LEVEL_PACKAGE_NAMES: ReadonlySet<string> = new Set<string>([
+  "build",
+  "java",
+  "kotlin",
+  "land",
+  "okio",
+]);
+
+const JAVA_OBJECT_SYMBOLS: ReadonlySet<string> = new Set([
+  "clone",
+  "equals",
+  "finalize",
+  "getClass",
+  "hashCode",
+  "notify",
+  "notifyAll",
+  "toString",
+  "wait",
+]);
+
+const GENERATED_STRUCT_SYMBOLS: ReadonlySet<string> = new Set([
+  "builder",
+  "partialBuilder",
+  "toBuilder",
+]);
+
+export function toEnumConstantName(field: Field): string {
+  const skirName = field.name.text;
+  return skirName === "SERIALIZER" || skirName === "TYPE_DESCRIPTOR"
+    ? `${skirName}_`
+    : skirName;
+}

package/src/type_speller.ts

@@ -0,0 +1,185 @@
+import type { RecordKey, RecordLocation, ResolvedType } from "skir-internal";
+import { ClassName, Namer } from "./naming.js";
+
+export type TypeFlavor = "initializer" | "frozen" | "frozen-key";
+
+/**
+ * Transforms a type found in a `.skir` file into a Java type.
+ */
+export class TypeSpeller {
+  constructor(
+    readonly recordMap: ReadonlyMap<RecordKey, RecordLocation>,
+    private readonly namer: Namer,
+  ) {}
+
+  getJavaType(
+    type: ResolvedType,
+    flavor: TypeFlavor,
+    mustBeObject?: "must-be-object",
+  ): string {
+    switch (type.kind) {
+      case "record": {
+        const recordLocation = this.recordMap.get(type.key)!;
+        const record = recordLocation.record;
+        const className = this.namer.getClassName(recordLocation).qualifiedName;
+        if (record.recordType === "struct") {
+          return className;
+        }
+        // An enum.
+        const _: "enum" = record.recordType;
+        if (flavor === "initializer" || flavor === "frozen") {
+          return className;
+        } else if (flavor === "frozen-key") {
+          return `${className}.Kind`;
+        } else {
+          const _: never = flavor;
+          throw TypeError();
+        }
+      }
+      case "array": {
+        const itemType = this.getJavaType(type.item, flavor, "must-be-object");
+        if (flavor === "initializer") {
+          return `java.lang.Iterable<? extends ${itemType}>`;
+        } else if (flavor === "frozen" || flavor === "frozen-key") {
+          if (type.key) {
+            const { keyType } = type.key;
+            const javaKeyType = this.getJavaType(
+              keyType,
+              "frozen-key",
+              "must-be-object",
+            );
+            return `build.skir.KeyedList<${itemType}, ${javaKeyType}>`;
+          } else {
+            return `java.util.List<${itemType}>`;
+          }
+        } else {
+          const _: "kind" = flavor;
+          throw TypeError();
+        }
+      }
+      case "optional": {
+        const otherType = this.getJavaType(
+          type.other,
+          flavor,
+          "must-be-object",
+        );
+        return `java.util.Optional<${otherType}>`;
+      }
+      case "primitive": {
+        const { primitive } = type;
+        if (mustBeObject) {
+          switch (primitive) {
+            case "bool":
+              return "java.lang.Boolean";
+            case "int32":
+              return "java.lang.Integer";
+            case "int64":
+            case "uint64":
+              return "java.lang.Long";
+            case "float32":
+              return "java.lang.Float";
+            case "float64":
+              return "java.lang.Double";
+            case "timestamp":
+              return "java.time.Instant";
+            case "string":
+              return "java.lang.String";
+            case "bytes":
+              return "okio.ByteString";
+            default: {
+              const _: never = primitive;
+              throw TypeError();
+            }
+          }
+        } else {
+          switch (primitive) {
+            case "bool":
+              return "boolean";
+            case "int32":
+              return "int";
+            case "int64":
+            case "uint64":
+              return "long";
+            case "float32":
+              return "float";
+            case "float64":
+              return "double";
+            case "timestamp":
+              return "java.time.Instant";
+            case "string":
+              return "java.lang.String";
+            case "bytes":
+              return "okio.ByteString";
+            default: {
+              const _: never = primitive;
+              throw TypeError();
+            }
+          }
+        }
+      }
+    }
+  }
+
+  getClassName(recordKey: RecordKey): ClassName {
+    const record = this.recordMap.get(recordKey)!;
+    return this.namer.getClassName(record);
+  }
+
+  getSerializerExpression(type: ResolvedType): string {
+    switch (type.kind) {
+      case "primitive": {
+        switch (type.primitive) {
+          case "bool":
+            return "build.skir.Serializers.bool()";
+          case "int32":
+            return "build.skir.Serializers.int32()";
+          case "int64":
+            return "build.skir.Serializers.int64()";
+          case "uint64":
+            return "build.skir.Serializers.javaUint64()";
+          case "float32":
+            return "build.skir.Serializers.float32()";
+          case "float64":
+            return "build.skir.Serializers.float64()";
+          case "timestamp":
+            return "build.skir.Serializers.timestamp()";
+          case "string":
+            return "build.skir.Serializers.string()";
+          case "bytes":
+            return "build.skir.Serializers.bytes()";
+        }
+        const _: never = type.primitive;
+        throw TypeError();
+      }
+      case "array": {
+        if (type.key) {
+          const keyChain = type.key.path.map((f) => f.name.text).join(".");
+          const path = type.key.path
+            .map((f) => this.namer.structFieldToJavaName(f.name.text) + "()")
+            .join(".");
+          return (
+            "build.skir.internal.ListSerializerKt.keyedListSerializer(\n" +
+            this.getSerializerExpression(type.item) +
+            `,\n"${keyChain}",\n(it) -> it.${path}\n)`
+          );
+        } else {
+          return (
+            "build.skir.Serializers.list(\n" +
+            this.getSerializerExpression(type.item) +
+            "\n)"
+          );
+        }
+      }
+      case "optional": {
+        return (
+          `build.skir.Serializers.javaOptional(\n` +
+          this.getSerializerExpression(type.other) +
+          `\n)`
+        );
+      }
+      case "record": {
+        return this.getClassName(type.key).qualifiedName + ".SERIALIZER";
+      }
+    }
+  }
+}