xbintsc 0.2.9 → 0.3.3

package/src/codegen/generator/calls/literals.ts

@@ -0,0 +1,77 @@
+/**
+ * Literal lowering: array and object literals (including spread elements).
+ */
+
+import {
+  SyntaxKind,
+  type ArrayLiteralExpression,
+  type Expression,
+  type ObjectLiteralExpression,
+} from "../../../ast/nodes.js";
+import { propertyNameText } from "../tables.js";
+import type { Generator } from "../generator.js";
+
+export interface LiteralCallMethods {
+  emitArrayLiteral(this: Generator, node: ArrayLiteralExpression): string;
+  emitObjectLiteral(this: Generator, node: ObjectLiteralExpression): string;
+}
+
+export const literalCallMethods: LiteralCallMethods = {
+  emitArrayLiteral(node: ArrayLiteralExpression): string {
+    const hasSpread = node.elements.some((element) => element.kind === SyntaxKind.SpreadElement);
+    if (!hasSpread) {
+      const args = this.emitArguments(node.elements);
+      const result = this.reg();
+      this.emit(`  ${result} = call i64 @xt_array_new(i32 ${args.argc}, i64* ${args.ptr})`);
+      return result;
+    }
+    const array = this.reg();
+    this.emit(`  ${array} = call i64 @xt_array_new(i32 0, i64* null)`);
+    for (const element of node.elements) {
+      if (element.kind === SyntaxKind.SpreadElement) {
+        const spread = this.emitExpression((element as { expression: Expression }).expression);
+        this.emit(`  call i64 @xt_array_spread(i64 ${array}, i64 ${spread})`);
+      } else {
+        const value = this.emitExpression(element);
+        this.emit(`  call i64 @xt_array_push(i64 ${array}, i64 ${value})`);
+      }
+    }
+    return array;
+  },
+
+  emitObjectLiteral(node: ObjectLiteralExpression): string {
+    const object = this.reg();
+    this.emit(`  ${object} = call i64 @xt_object_new()`);
+    for (const property of node.properties) {
+      if (property.kind === SyntaxKind.PropertyAssignment) {
+        const nameNode = property.name;
+        let key: string;
+        if (nameNode.kind === SyntaxKind.ComputedPropertyName) {
+          const keyValue = this.emitExpression((nameNode as { expression: Expression }).expression);
+          key = this.reg();
+          this.emit(`  ${key} = call i64 @xt_to_string(i64 ${keyValue})`);
+        } else {
+          key = this.stringValue(propertyNameText(nameNode));
+        }
+        const value = this.emitExpression(property.initializer);
+        this.emit(`  call i64 @xt_set(i64 ${object}, i64 ${key}, i64 ${value})`);
+      } else if (property.kind === SyntaxKind.ShorthandPropertyAssignment) {
+        if (property.initializer) {
+          // `{ a = 1 }` is only legal as a destructuring target, not a value.
+          this.unsupported(property, "default value in object literal");
+          continue;
+        }
+        const identifier = property.name;
+        const key = this.stringValue(identifier.text);
+        const value = this.emitIdentifier(identifier);
+        this.emit(`  call i64 @xt_set(i64 ${object}, i64 ${key}, i64 ${value})`);
+      } else if (property.kind === SyntaxKind.SpreadElement) {
+        const spread = this.emitExpression((property as { expression: Expression }).expression);
+        this.emit(`  call i64 @xt_object_spread(i64 ${object}, i64 ${spread})`);
+      } else {
+        this.unsupported(property, "object spread");
+      }
+    }
+    return object;
+  },
+};

package/src/codegen/generator/calls/super.ts

@@ -0,0 +1,61 @@
+/**
+ * `super` lowering: parent constructor delegation and parent method calls.
+ */
+
+import {
+  SyntaxKind,
+  type CallExpression,
+  type Identifier,
+  type PropertyAccessExpression,
+} from "../../../ast/nodes.js";
+import type { Generator } from "../generator.js";
+
+export interface SuperCallMethods {
+  emitSuperConstructor(this: Generator, node: CallExpression): string;
+  emitSuperCall(this: Generator, node: CallExpression, access: PropertyAccessExpression): string;
+}
+
+export const superCallMethods: SuperCallMethods = {
+  emitSuperConstructor(node: CallExpression): string {
+    const thisValue = this.emitThis();
+    const classInfo = this.current.fn.classInfo;
+    const parent = classInfo?.parentExpression;
+    const unboundBuiltin =
+      parent !== undefined &&
+      parent.kind === SyntaxKind.Identifier &&
+      (parent as Identifier).text === "Error" &&
+      !this.binding.symbolOfIdentifier.get(parent as Identifier);
+    if (unboundBuiltin) {
+      const args = this.emitArguments(node.arguments);
+      const result = this.reg();
+      this.emit(`  ${result} = call i64 @xt_error_init(i64 ${thisValue}, i32 ${args.argc}, i64* ${args.ptr})`);
+      return result;
+    }
+    const proto = this.reg();
+    this.emit(`  ${proto} = call i64 @xt_object_get_prototype(i64 ${thisValue})`);
+    const parentProto = this.reg();
+    this.emit(`  ${parentProto} = call i64 @xt_object_get_prototype(i64 ${proto})`);
+    const key = this.stringValue("__ctor");
+    const ctor = this.reg();
+    this.emit(`  ${ctor} = call i64 @xt_get(i64 ${parentProto}, i64 ${key})`);
+    const args = this.emitArguments(node.arguments);
+    const result = this.reg();
+    this.emit(`  ${result} = call i64 @xt_call_with_this(i64 ${ctor}, i64 ${thisValue}, i32 ${args.argc}, i64* ${args.ptr})`);
+    return result;
+  },
+
+  emitSuperCall(node: CallExpression, access: PropertyAccessExpression): string {
+    const thisValue = this.emitThis();
+    const proto = this.reg();
+    this.emit(`  ${proto} = call i64 @xt_object_get_prototype(i64 ${thisValue})`);
+    const parentProto = this.reg();
+    this.emit(`  ${parentProto} = call i64 @xt_object_get_prototype(i64 ${proto})`);
+    const key = this.stringValue(access.name.text);
+    const method = this.reg();
+    this.emit(`  ${method} = call i64 @xt_get(i64 ${parentProto}, i64 ${key})`);
+    const args = this.emitArguments(node.arguments);
+    const result = this.reg();
+    this.emit(`  ${result} = call i64 @xt_call_with_this(i64 ${method}, i64 ${thisValue}, i32 ${args.argc}, i64* ${args.ptr})`);
+    return result;
+  },
+};