xbintsc 0.1.6 → 0.1.9

package/src/codegen/generator/module.ts

@@ -0,0 +1,244 @@
+/**
+ * Module-level generation: emitting functions, the entry point and the overall
+ * IR text, plus default-parameter initialization.
+ */
+
+import {
+  SyntaxKind,
+  type ArrowFunction,
+  type Block,
+  type Expression,
+  type Parameter,
+} from "../../ast/nodes.js";
+import type { ClassInfo, FunctionInfo, SymbolInfo } from "../../binder/binder.js";
+import { SymbolKind } from "../../binder/binder.js";
+import { i64, XT_UNDEFINED } from "../values.js";
+import { RUNTIME_DECLARATIONS, type FunctionState } from "./state.js";
+import type { Generator } from "./generator.js";
+
+export interface ModuleMethods {
+  run(this: Generator): string;
+  emitFunction(this: Generator, fn: FunctionInfo): void;
+  emitMain(this: Generator): void;
+  functionName(this: Generator, fn: FunctionInfo): string;
+  wrapAsync(this: Generator, value: string): string;
+  classGlobal(this: Generator, classInfo: ClassInfo): string;
+  emitClassReference(this: Generator, classInfo: ClassInfo): string;
+  emitClassSetup(this: Generator, classInfo: ClassInfo): void;
+  emitDefaultParameter(this: Generator, symbol: SymbolInfo, value: string, initializer: Expression): void;
+}
+
+export const moduleMethods: ModuleMethods = {
+  run(): string {
+    for (const classInfo of this.binding.classes) {
+      const globalName = `@class.${classInfo.id}`;
+      this.classGlobals.set(classInfo.id, globalName);
+      this.globals.push(`${globalName} = internal global i64 0`);
+    }
+    // Module-level bindings captured by functions live in globals so that a
+    // top-level function can see them without a closure environment.
+    const moduleScope = this.binding.scopes.get(this.sourceFile);
+    if (moduleScope) {
+      for (const symbol of moduleScope.symbols.values()) {
+        const isVariable = symbol.kind === SymbolKind.Var || symbol.kind === SymbolKind.Let || symbol.kind === SymbolKind.Const;
+        if (!isVariable || !symbol.boxed || !symbol.fn.isModule) continue;
+        const globalName = `@g.${symbol.id}`;
+        this.moduleGlobals.set(symbol.id, globalName);
+        this.globals.push(`${globalName} = internal global i64 ${i64(XT_UNDEFINED)}`);
+      }
+    }
+    for (const fn of this.binding.functions) this.emitFunction(fn);
+    this.emitMain();
+    const header = ["; ModuleID = 'xbintsc'", "source_filename = \"" + this.sourceFile.fileName + "\"", ""];
+    return [...header, ...RUNTIME_DECLARATIONS, ...this.extraDeclarations, "", ...this.globals, "", ...this.functions, ""].join("\n");
+  },
+
+  // -- module level --------------------------------------------------------
+
+  emitFunction(fn: FunctionInfo): void {
+    const name = this.functionName(fn);
+    const state: FunctionState = {
+      fn,
+      buffer: [],
+      allocas: [],
+      slots: new Map(),
+      reg: 0,
+      label: 0,
+      terminated: false,
+      loops: [],
+      tryFrames: [],
+      escapePointers: [],
+      usesTry: false,
+    };
+    this.current = state;
+
+    const header = `define i64 @${name}(i64 %this, i64 %env, i32 %argc, i64* %argv) {`;
+    this.emit(`%saved.env = alloca i64`);
+    this.emit(`store i64 %env, i64* %saved.env`);
+    this.emit(`%saved.this = alloca i64`);
+    this.emit(`store i64 %this, i64* %saved.this`);
+    state.thisPtr = "%saved.this";
+    this.emit(`%saved.argc = alloca i32`);
+    this.emit(`store i32 %argc, i32* %saved.argc`);
+    this.emit(`%saved.argv = alloca i64*`);
+    this.emit(`store i64* %argv, i64** %saved.argv`);
+
+    // Parameters.
+    const parameterNodes = (fn.node as { parameters?: Parameter[] }).parameters ?? [];
+    for (let index = 0; index < fn.params.length; index++) {
+      const symbol = fn.params[index]!;
+      const parameter = parameterNodes[index];
+      if (parameter?.dotDotDotToken) {
+        const rest = this.reg();
+        this.emit(`  ${rest} = call i64 @xt_rest_args(i32 %argc, i64* %argv, i32 ${index})`);
+        this.declareSlot(symbol, rest);
+        continue;
+      }
+      const value = this.reg();
+      this.emit(`  ${value} = call i64 @xt_arg(i32 %argc, i64* %argv, i32 ${index})`);
+      this.declareSlot(symbol, value);
+      if (parameter?.initializer) this.emitDefaultParameter(symbol, value, parameter.initializer);
+    }
+
+    // Captures threaded through the environment.
+    for (const symbol of fn.captures) {
+      if (this.moduleGlobals.has(symbol.id)) continue;
+      const index = fn.captureIndex.get(symbol.id)!;
+      const value = this.reg();
+      this.emit(`  ${value} = call i64 @xt_closure_env(i64 %env, i32 ${index})`);
+      this.defineCaptureSlot(symbol, value);
+    }
+
+    // Arrow functions inherit `this` lexically; it travels as an extra capture.
+    if (fn.isArrow && fn.capturesThis) {
+      const inherited = this.reg();
+      this.emit(`  ${inherited} = call i64 @xt_closure_env(i64 %env, i32 ${fn.captures.length})`);
+      this.emit(`  store i64 ${inherited}, i64* %saved.this`);
+    }
+
+    // Instance field initializers run before the constructor body.
+    if (fn.isConstructor && fn.classInfo) {
+      const thisValue = this.emitThis();
+      for (const field of fn.classInfo.fields) {
+        if (field.isStatic) continue;
+        const key = this.stringValue(field.name);
+        const value = field.initializer ? this.emitExpression(field.initializer) : i64(XT_UNDEFINED);
+        this.emit(`  call i64 @xt_set(i64 ${thisValue}, i64 ${key}, i64 ${value})`);
+      }
+    }
+
+    // Body.
+    if (fn.node.kind === SyntaxKind.SourceFile) {
+      this.emitStatements(this.sourceFile.statements);
+    } else if (fn.node.kind === SyntaxKind.ArrowFunction && (fn.node as ArrowFunction).body.kind !== SyntaxKind.Block) {
+      const value = this.emitExpression((fn.node as ArrowFunction).body as Expression);
+      this.terminate(`ret i64 ${fn.isAsync ? this.wrapAsync(value) : value}`);
+    } else {
+      const body = (fn.node as { body: Block }).body;
+      if (body) this.emitStatements(body.statements);
+    }
+
+    if (!this.current.terminated) {
+      const fallback = fn.isAsync ? this.wrapAsync(i64(XT_UNDEFINED)) : i64(XT_UNDEFINED);
+      this.terminate(`ret i64 ${fallback}`);
+    }
+
+    const escapes = state.usesTry
+      ? state.escapePointers.map((ptr) => `  call void asm sideeffect "", "r"(i64* ${ptr})`)
+      : [];
+    const lines = [...state.allocas.map((a) => `  ${a}`), ...escapes, ...state.buffer];
+    this.functions.push([header, ...lines, "}", ""].join("\n"));
+  },
+
+  emitMain(): void {
+    const moduleName = this.functionName(this.binding.moduleFunction);
+    this.functions.push(
+      [
+        "define i32 @main(i32 %argc, i8** %argv) {",
+        `  %result = call i64 @${moduleName}(i64 ${i64(XT_UNDEFINED)}, i64 ${i64(XT_UNDEFINED)}, i32 0, i64* null)`,
+        "  call void @xt_drain_microtasks()",
+        "  ret i32 0",
+        "}",
+        "",
+      ].join("\n"),
+    );
+  },
+
+  functionName(fn: FunctionInfo): string {
+    return fn.isModule ? "xt_module" : `xt_fn_${fn.id}`;
+  },
+
+  /** Wrap a returned value in a resolved promise (for `async` functions). */
+  wrapAsync(value: string): string {
+    const result = this.reg();
+    this.emit(`  ${result} = call i64 @xt_promise_resolve(i64 ${value})`);
+    return result;
+  },
+
+  classGlobal(classInfo: ClassInfo): string {
+    const existing = this.classGlobals.get(classInfo.id);
+    if (existing) return existing;
+    const name = `@class.${classInfo.id}`;
+    this.classGlobals.set(classInfo.id, name);
+    this.globals.push(`${name} = internal global i64 0`);
+    return name;
+  },
+
+  emitClassReference(classInfo: ClassInfo): string {
+    const globalName = this.classGlobal(classInfo);
+    const value = this.reg();
+    this.emit(`  ${value} = load i64, i64* ${globalName}`);
+    return value;
+  },
+
+  /** Build a class value (constructor closure + prototype) and store it in its global. */
+  emitClassSetup(classInfo: ClassInfo): void {
+    const globalName = this.classGlobal(classInfo);
+    const proto = this.reg();
+    this.emit(`  ${proto} = call i64 @xt_object_new()`);
+    if (classInfo.parentExpression) {
+      const parent = this.emitExpression(classInfo.parentExpression);
+      const parentProto = this.reg();
+      this.emit(`  ${parentProto} = call i64 @xt_function_get_prototype(i64 ${parent})`);
+      this.emit(`  call i64 @xt_object_set_prototype(i64 ${proto}, i64 ${parentProto})`);
+    }
+    for (const method of classInfo.methods) {
+      const fnValue = this.emitClosureValue(method);
+      const key = this.stringValue(method.name);
+      this.emit(`  call i64 @xt_set(i64 ${proto}, i64 ${key}, i64 ${fnValue})`);
+    }
+    const ctor = this.emitClosureValue(classInfo.ctor!);
+    this.emit(`  call i64 @xt_function_set_prototype(i64 ${ctor}, i64 ${proto})`);
+    const ctorKey = this.stringValue("__ctor");
+    this.emit(`  call i64 @xt_set(i64 ${proto}, i64 ${ctorKey}, i64 ${ctor})`);
+    for (const method of classInfo.statics) {
+      const fnValue = this.emitClosureValue(method);
+      const key = this.stringValue(method.name);
+      this.emit(`  call i64 @xt_set(i64 ${ctor}, i64 ${key}, i64 ${fnValue})`);
+    }
+    for (const field of classInfo.fields) {
+      if (!field.isStatic) continue;
+      const key = this.stringValue(field.name);
+      const value = field.initializer ? this.emitExpression(field.initializer) : i64(XT_UNDEFINED);
+      this.emit(`  call i64 @xt_set(i64 ${ctor}, i64 ${key}, i64 ${value})`);
+    }
+    this.emit(`  store i64 ${ctor}, i64* ${globalName}`);
+  },
+
+  emitDefaultParameter(symbol: SymbolInfo, value: string, initializer: Expression): void {
+    const isUndefined = this.reg();
+    this.emit(`  ${isUndefined} = call i64 @xt_seq(i64 ${value}, i64 ${i64(XT_UNDEFINED)})`);
+    const truthy = this.reg();
+    this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${isUndefined})`);
+    const condition = this.reg();
+    this.emit(`  ${condition} = icmp ne i32 ${truthy}, 0`);
+    const applyLabel = this.label("param.default");
+    const endLabel = this.label("param.end");
+    this.terminate(`br i1 ${condition}, label %${applyLabel}, label %${endLabel}`);
+    this.startBlock(applyLabel);
+    const fallback = this.emitExpression(initializer);
+    this.writeSlot(symbol, fallback);
+    this.terminate(`br label %${endLabel}`);
+    this.startBlock(endLabel);
+  },
+};

package/src/codegen/generator/state.ts

@@ -0,0 +1,169 @@
+/**
+ * Shared state types and the runtime declaration list for the LLVM generator.
+ */
+
+import type { FunctionInfo } from "../../binder/binder.js";
+import type { BindResult } from "../../binder/binder.js";
+import type { BuiltinFunction } from "../../extensions/registry.js";
+
+export interface Slot {
+  /** Register holding the `i64*` to the storage. */
+  readonly ptr: string;
+  readonly boxed: boolean;
+}
+
+export interface LoopLabels {
+  readonly breakLabel: string;
+  readonly continueLabel: string;
+  /** Number of enclosing `try` frames when the loop was entered. */
+  readonly tryDepth?: number;
+}
+
+export interface FunctionState {
+  readonly fn: FunctionInfo;
+  readonly buffer: string[];
+  readonly allocas: string[];
+  readonly slots: Map<number, Slot>;
+  reg: number;
+  label: number;
+  terminated: boolean;
+  readonly loops: LoopLabels[];
+  readonly tryFrames: string[];
+  readonly escapePointers: string[];
+  /** Alloca holding the `this` binding for the current function. */
+  thisPtr?: string;
+  /** Set when the function contains a `try`, forcing locals to live in memory. */
+  usesTry: boolean;
+}
+
+export interface CodegenResult {
+  readonly ir: string;
+  readonly binding: BindResult;
+}
+
+export interface CodegenOptions {
+  /** Global names supplied by registered extensions. */
+  readonly builtins?: Readonly<Record<string, BuiltinFunction>>;
+}
+
+export const RUNTIME_DECLARATIONS: readonly string[] = [
+  "declare i64 @xt_undefined()",
+  "declare i64 @xt_null()",
+  "declare i64 @xt_bool(i32)",
+  "declare i64 @xt_number(double)",
+  "declare i64 @xt_string_new(i8*, i64)",
+  "declare i64 @xt_string_from_cstr(i8*)",
+  "declare i64 @xt_arg(i32, i64*, i32)",
+  "declare i64 @xt_closure_new(i8*, i32, i64*)",
+  "declare i64 @xt_closure_call(i64, i32, i64*)",
+  "declare i64 @xt_closure_env(i64, i32)",
+  "declare i64 @xt_call_with_this(i64, i64, i32, i64*)",
+  "declare i64 @xt_this()",
+  "declare i64 @xt_new(i64, i32, i64*)",
+  "declare i64 @xt_instance_of(i64, i64)",
+  "declare i64 @xt_function_set_prototype(i64, i64)",
+  "declare i64 @xt_function_get_prototype(i64)",
+  "declare i64 @xt_object_new_with_proto(i64)",
+  "declare i64 @xt_object_get_prototype(i64)",
+  "declare i64 @xt_object_set_prototype(i64, i64)",
+  "declare i64 @xt_await(i64)",
+  "declare void @xt_drain_microtasks()",
+  "declare i64 @xt_promise_resolve(i64)",
+  "declare i64 @xt_promise_reject(i64)",
+  "declare i64 @xt_promise_ctor(i32, i64*)",
+  "declare i64 @xt_promise_static(i64, i32, i64*)",
+  "declare i64 @xt_array_static(i64, i32, i64*)",
+  "declare i64 @xt_object_static(i64, i32, i64*)",
+  "declare i64 @xt_number_static(i64, i32, i64*)",
+  "declare i64 @xt_string_static(i64, i32, i64*)",
+  "declare i64 @xt_date_static(i64, i32, i64*)",
+  "declare i64 @xt_map_ctor(i32, i64*)",
+  "declare i64 @xt_set_ctor(i32, i64*)",
+  "declare i64 @xt_date_ctor(i32, i64*)",
+  "declare i64 @xt_regexp_ctor(i32, i64*)",
+  "declare i64 @xt_json_parse(i32, i64*)",
+  "declare i64 @xt_json_stringify(i32, i64*)",
+  "declare i64 @xt_object_from_entries(i64)",
+  "declare i64 @xt_object_freeze(i64)",
+  "declare i32 @xt_object_is_frozen(i64)",
+  "declare i64 @xt_object_has_own(i64, i64)",
+  "declare i64 @xt_console_dir(i32, i64*)",
+  "declare i64 @xt_console_trace(i32, i64*)",
+  "declare i64 @xt_console_assert(i32, i64*)",
+  "declare i64 @xt_console_count(i32, i64*)",
+  "declare i64 @xt_console_count_reset(i32, i64*)",
+  "declare i64 @xt_console_group(i32, i64*)",
+  "declare i64 @xt_console_group_end(i32, i64*)",
+  "declare i64 @xt_console_table(i32, i64*)",
+  "declare i64 @xt_console_time(i32, i64*)",
+  "declare i64 @xt_console_time_end(i32, i64*)",
+  "declare i64 @xt_console_time_log(i32, i64*)",
+  "declare i32 @xt_truthy(i64)",
+  "declare double @xt_to_number(i64)",
+  "declare i64 @xt_to_string(i64)",
+  "declare i64 @xt_typeof(i64)",
+  "declare i64 @xt_add(i64, i64)",
+  "declare i64 @xt_sub(i64, i64)",
+  "declare i64 @xt_mul(i64, i64)",
+  "declare i64 @xt_div(i64, i64)",
+  "declare i64 @xt_mod(i64, i64)",
+  "declare i64 @xt_pow(i64, i64)",
+  "declare i64 @xt_neg(i64)",
+  "declare i64 @xt_pos(i64)",
+  "declare i64 @xt_bit_and(i64, i64)",
+  "declare i64 @xt_bit_or(i64, i64)",
+  "declare i64 @xt_bit_xor(i64, i64)",
+  "declare i64 @xt_bit_not(i64)",
+  "declare i64 @xt_shl(i64, i64)",
+  "declare i64 @xt_shr(i64, i64)",
+  "declare i64 @xt_ushr(i64, i64)",
+  "declare i64 @xt_lt(i64, i64)",
+  "declare i64 @xt_le(i64, i64)",
+  "declare i64 @xt_gt(i64, i64)",
+  "declare i64 @xt_ge(i64, i64)",
+  "declare i64 @xt_eq(i64, i64)",
+  "declare i64 @xt_ne(i64, i64)",
+  "declare i64 @xt_seq(i64, i64)",
+  "declare i64 @xt_sne(i64, i64)",
+  "declare i64 @xt_not(i64)",
+  "declare i64 @xt_object_new()",
+  "declare i64 @xt_object_get_cstr(i64, i8*)",
+  "declare i64 @xt_object_set(i64, i64, i64)",
+  "declare i64 @xt_object_has(i64, i64)",
+  "declare i64 @xt_object_keys(i64)",
+  "declare i64 @xt_object_values(i64)",
+  "declare i64 @xt_object_entries(i64)",
+  "declare i64 @xt_object_assign(i32, i64*)",
+  "declare i64 @xt_object_spread(i64, i64)",
+  "declare i64 @xt_call_method(i64, i64, i32, i64*)",
+  "declare i64 @xt_math_call(i64, i32, i64*)",
+  "declare i64 @xt_parse_int(i32, i64*)",
+  "declare i64 @xt_parse_float(i32, i64*)",
+  "declare i64 @xt_is_nan(i32, i64*)",
+  "declare i64 @xt_is_finite(i32, i64*)",
+  "declare i64 @xt_number_ctor(i32, i64*)",
+  "declare i64 @xt_string_ctor(i32, i64*)",
+  "declare i64 @xt_boolean_ctor(i32, i64*)",
+  "declare i64 @xt_in(i64, i64)",
+  "declare i64 @xt_delete(i64, i64)",
+  "declare i64 @xt_rest_args(i32, i64*, i32)",
+  "declare i64 @xt_array_new(i32, i64*)",
+  "declare i64 @xt_array_push(i64, i64)",
+  "declare i64 @xt_array_length(i64)",
+  "declare i64 @xt_array_spread(i64, i64)",
+  "declare i64 @xt_get(i64, i64)",
+  "declare i64 @xt_set(i64, i64, i64)",
+  "declare i64 @xt_box_new(i64)",
+  "declare i64 @xt_box_get(i64)",
+  "declare i64 @xt_box_set(i64, i64)",
+  "declare i64 @xt_is_nullish(i64)",
+  "declare void @xt_throw(i64)",
+  "declare i32 @_setjmp(i8*) returns_twice",
+  "declare i8* @xt_try_enter()",
+  "declare i64 @xt_try_exception(i8*)",
+  "declare void @xt_try_leave(i8*)",
+  "declare void @xt_console_log(i32, i64*)",
+  "declare void @xt_console_info(i32, i64*)",
+  "declare void @xt_console_warn(i32, i64*)",
+  "declare void @xt_console_error(i32, i64*)",
+];