skir-cc-gen 0.0.1

package/src/keywords.ts

@@ -0,0 +1,100 @@
+// From https://en.cppreference.com/w/cpp/keyword
+export const CC_KEYWORDS: ReadonlySet<string> = new Set<string>([
+  "alignas",
+  "alignof",
+  "and",
+  "and_eq",
+  "asm",
+  "atomic_cancel",
+  "atomic_commit",
+  "atomic_noexcept",
+  "auto",
+  "bitand",
+  "bitor",
+  "bool",
+  "break",
+  "case",
+  "catch",
+  "char",
+  "char8_t",
+  "char16_t",
+  "char32_t",
+  "class",
+  "compl",
+  "concept",
+  "const",
+  "consteval",
+  "constexpr",
+  "constinit",
+  "const_cast",
+  "continue",
+  "co_await",
+  "co_return",
+  "co_yield",
+  "decltype",
+  "default",
+  "delete",
+  "do",
+  "double",
+  "dynamic_cast",
+  "else",
+  "enum",
+  "explicit",
+  "export",
+  "extern",
+  "false",
+  "float",
+  "for",
+  "friend",
+  "goto",
+  "if",
+  "inline",
+  "int",
+  "long",
+  "mutable",
+  "namespace",
+  "new",
+  "noexcept",
+  "not",
+  "not_eq",
+  "nullptr",
+  "operator",
+  "or",
+  "or_eq",
+  "private",
+  "protected",
+  "public",
+  "reflexpr",
+  "register",
+  "reinterpret_cast",
+  "requires",
+  "return",
+  "short",
+  "signed",
+  "sizeof",
+  "static",
+  "static_assert",
+  "static_cast",
+  "struct",
+  "switch",
+  "synchronized",
+  "template",
+  "this",
+  "thread_local",
+  "throw",
+  "true",
+  "try",
+  "typedef",
+  "typeid",
+  "typename",
+  "union",
+  "unsigned",
+  "using",
+  "virtual",
+  "void",
+  "volatile",
+  "wchar_t",
+  "while",
+  "xor",
+  "xor_eq",
+]);

package/src/recursivity_resolver.ts

@@ -0,0 +1,161 @@
+import {
+  Field,
+  Module,
+  RecordKey,
+  RecordLocation,
+  ResolvedType,
+} from "skir-internal";
+
+/**
+ * In C++, a struct type can not refer to itself directly. The only way to create a
+ * recursive struct is to use pointers or containers which allocate their elements on
+ * the heap, e.g. `std::vector`. Neither `absl::optional` nor `absl::variant` qualify
+ * because they allocate the element on the stack.
+ *
+ * When generating C++ types from recursive Skir types, Skir uses `rec<T>` instead of
+ * `T` for the fields which cause the type to be recursive.
+ *
+ * Consider this example:
+ *
+ *   struct Foo {
+ *     bar: Bar;
+ *   }
+ *
+ *   struct Bar {
+ *     foo: Foo?;
+ *     x: int32;
+ *   }
+ *
+ * Both Foo and Bar are recursive since Foo refers to Bar and Bar refers to Foo, so Foo
+ * indirectly refers to itself and so does Bar.
+ *
+ * This is the C++ code Skir generates:
+ *   struct Foo;
+ *   struct Bar;
+ *
+ *   struct Foo {
+ *     rec<Bar> bar;
+ *   };
+ *
+ *   struct Bar {
+ *     absl::optional<Foo> foo;
+ *     int32 x = 0;
+ *   };
+ *
+ * Because the type of Foo:bar is `rec<Bar>` instead of `Bar`, Foo no longer refers to
+ * Bar and thus Foo no longer refers to itself, and Bar no longer refers to itself
+ * either: problem solved.
+ * The same outcome would have been reached by changing the type of Bar::foo instead of
+ * Foo::bar.
+ *
+ * This class finds the fields of the skir types which should have a `rec<...>` type in
+ * their C++ representation.
+ */
+export class RecursvityResolver {
+  static resolve(
+    recordMap: ReadonlyMap<RecordKey, RecordLocation>,
+    module: Module,
+  ): RecursvityResolver {
+    const sortedRecords = [...module.records].sort((a, b) => {
+      const aKey = a.recordAncestors.map((r) => r.name).join(".");
+      const bKey = b.recordAncestors.map((r) => r.name).join(".");
+      return aKey.localeCompare(bKey, "en-US");
+    });
+    const recursiveFields = new Set<Field>();
+    const recordToDeps = new Map<RecordKey, Set<RecordKey>>();
+    for (const record of sortedRecords) {
+      const recordDeps = new Set<RecordKey>();
+      for (const field of record.record.fields) {
+        if (!field.type) continue;
+        const depsCollector = new DepsCollector(
+          recordMap,
+          module.path,
+          recursiveFields,
+        );
+        depsCollector.collect(field.type);
+        if (depsCollector.deps.has(record.record.key)) {
+          recursiveFields.add(field);
+        } else {
+          depsCollector.deps.forEach((dep) => recordDeps.add(dep));
+        }
+      }
+      recordToDeps.set(record.record.key, recordDeps);
+    }
+    const reorderedRecords = reorderRecords(
+      sortedRecords,
+      recordToDeps,
+      recordMap,
+    );
+    return new RecursvityResolver(recursiveFields, reorderedRecords);
+  }
+
+  private constructor(
+    private readonly recursiveFields: ReadonlySet<Field>,
+    /**
+     * All records declared in the module, reordered sp every record appears after its
+     * dependencies.
+     */
+    readonly reorderedRecords: readonly RecordLocation[],
+  ) {}
+
+  isRecursive(field: Field): boolean {
+    return this.recursiveFields.has(field);
+  }
+}
+
+class DepsCollector {
+  constructor(
+    readonly recordMap: ReadonlyMap<RecordKey, RecordLocation>,
+    readonly modulePath: string,
+    readonly recursiveFields: ReadonlySet<Field>,
+  ) {}
+
+  readonly deps = new Set<RecordKey>();
+
+  collect(type: ResolvedType): void {
+    switch (type.kind) {
+      case "optional":
+        // absl::optional allocates its value on the stack.
+        this.collect(type.other);
+        break;
+      case "record": {
+        const recordKey = type.key;
+        const record = this.recordMap.get(recordKey)!;
+        // We only care about records declared in the module.
+        if (record.modulePath !== this.modulePath) break;
+        if (this.deps.has(recordKey)) break;
+        this.deps.add(recordKey);
+        // Wrapper variants of enums are allocated on the heap.
+        if (record.record.recordType === "enum") break;
+        for (const variant of record.record.fields) {
+          if (!variant.type) continue;
+          if (this.recursiveFields.has(variant)) continue;
+          this.collect(variant.type);
+        }
+      }
+    }
+  }
+}
+
+function reorderRecords(
+  inputRecords: readonly RecordLocation[],
+  recordToDeps: ReadonlyMap<RecordKey, Set<RecordKey>>,
+  recordMap: ReadonlyMap<RecordKey, RecordLocation>,
+): readonly RecordLocation[] {
+  const result: RecordLocation[] = [];
+  const seenRecords = new Set<RecordKey>();
+  function addRecord(record: RecordLocation): void {
+    const { key } = record.record;
+    if (seenRecords.has(key)) return;
+    seenRecords.add(key);
+    const deps = recordToDeps.get(key)!;
+    for (const dep of deps) {
+      addRecord(recordMap.get(dep)!);
+    }
+    result.push(record);
+  }
+  for (const record of inputRecords) {
+    addRecord(record);
+  }
+  return result;
+}

package/src/type_speller.ts

@@ -0,0 +1,100 @@
+import type {
+  Module,
+  RecordKey,
+  RecordLocation,
+  ResolvedType,
+} from "skir-internal";
+
+/**
+ * Transforms a type found in a `.skir` file into a C++ type.
+ */
+export class TypeSpeller {
+  constructor(
+    readonly recordMap: ReadonlyMap<RecordKey, RecordLocation>,
+    private readonly origin: Module,
+    private readonly includes: Set<string>,
+  ) {}
+
+  getCcType(
+    type: ResolvedType,
+    opts: {
+      fieldIsRecursive?: boolean;
+      forceNamespace?: boolean;
+    } = {},
+  ): string {
+    switch (type.kind) {
+      case "record": {
+        const record = this.recordMap.get(type.key)!;
+        let qualifiedName = getClassName(record);
+        if (record.modulePath !== this.origin.path || opts.forceNamespace) {
+          // The record is located in an imported module.
+          const path = record.modulePath;
+          if (record.modulePath !== this.origin.path) {
+            this.includes.add('"skirout/' + path.replace(/\.skir$/, '.h"'));
+          }
+          const namespace = modulePathToNamespace(path);
+          qualifiedName = `::${namespace}::${qualifiedName}`;
+        }
+        if (opts.fieldIsRecursive) {
+          return `::skir::rec<${qualifiedName}>`;
+        }
+        return qualifiedName;
+      }
+      case "array": {
+        const itemType = this.getCcType(type.item, opts);
+        const { key } = type;
+        if (key) {
+          const { path } = key;
+          let keyType = "";
+          for (const pathItem of path) {
+            const fieldName = pathItem.name.text;
+            const isLastField = pathItem === path.at(-1);
+            if (isLastField && key.keyType.kind === "record") {
+              keyType = `::skir::get_kind<${keyType}>`;
+            } else {
+              keyType = `::skirout::get_${fieldName}<${keyType}>`;
+            }
+          }
+          return `::skir::keyed_items<${itemType}, ${keyType}>`;
+        } else {
+          return `::std::vector<${itemType}>`;
+        }
+      }
+      case "optional": {
+        const valueType = this.getCcType(type.other, opts);
+        return `::absl::optional<${valueType}>`;
+      }
+      case "primitive": {
+        const { primitive } = type;
+        switch (primitive) {
+          case "bool":
+            return "bool";
+          case "int32":
+            return "::int32_t";
+          case "int64":
+            return "::int64_t";
+          case "uint64":
+            return "::uint64_t";
+          case "float32":
+            return "float";
+          case "float64":
+            return "double";
+          case "timestamp":
+            return "::absl::Time";
+          case "string":
+            return "::std::string";
+          case "bytes":
+            return "::skir::ByteString";
+        }
+      }
+    }
+  }
+}
+
+export function modulePathToNamespace(path: string): string {
+  return "skirout_" + path.replace(/\.skir$/, "").replace("/", "_");
+}
+
+export function getClassName(record: RecordLocation): string {
+  return record.recordAncestors.map((r) => r.name.text).join("_");
+}