xbintsc 0.3.79 → 0.3.87

package/src/codegen/generator/context.ts

@@ -54,11 +54,35 @@ export class GeneratorContext {
   readonly importDefaults = new Map<number, ModuleExport>();
   readonly globals: string[] = [];
   readonly functions: string[] = [];
-  readonly strings = new Map<string, { label: string; length: number }>();
+  readonly strings = new Map<string, { label: string; length: number; slot: string }>();
   readonly classGlobals = new Map<number, string>();
   readonly moduleGlobals = new Map<number, string>();
   readonly extraDeclarations = new Set<string>();
+  /** Static C strings used only as metadata (stack frame names/files). */
+  readonly staticStrings = new Map<string, string>();
+  /** Lazily built line-start indexes per source file, for stack frames. */
+  readonly lineStartsByFile = new Map<string, number[]>();
   stringCounter = 0;
+  staticCounter = 0;
+  /**
+   * How many `UnsupportedFeature` diagnostics the function currently being
+   * emitted produced. Unsupported constructs can leave the generator with a
+   * partially-bound tree; reporting the resulting invariant failures as
+   * "Internal: …" only buries the actionable error, so they are suppressed
+   * while this is non-zero.
+   */
+  unsupportedCount = 0;
+  /** Emit DWARF debug metadata (`--debug`). */
+  readonly debug: boolean;
+  /** Numbered metadata definitions, emitted after the functions. */
+  metadataCounter = 0;
+  readonly metadata: string[] = [];
+  readonly debugFiles = new Map<string, string>();
+  readonly debugSubprograms = new Map<number, string>();
+  readonly debugLocations = new Map<string, string>();
+  debugUnit?: string;
+  debugFlags: string[] = [];
+  debugSubroutineType?: string;
   current!: FunctionState;
 
   constructor(sourceFile: SourceFileNode, diagnostics: DiagnosticBag, options: CodegenOptions = {}) {
@@ -69,6 +93,7 @@ export class GeneratorContext {
     this.modules = options.modules ?? {};
     this.moduleHints = options.moduleHints ?? {};
     this.target = options.target ?? { platform: process.platform, arch: process.arch };
+    this.debug = options.debug === true;
     this.resolveImports();
   }
 
@@ -120,7 +145,7 @@ export class GeneratorContext {
               DiagnosticCode.ModuleNotFound,
               `Module '"${specifier}"' has no exported member '${importedName}'`,
               specifierNode.name,
-              this.sourceFile.fileName,
+              this.fileNameOf(specifierNode.name),
             );
             this.missingModuleSymbols.add(symbol.id);
           }
@@ -148,7 +173,7 @@ export class GeneratorContext {
         DiagnosticCode.ModuleNotFound,
         `module '${specifier}' is provided by the '${provider}' extension; pass --ext ${provider}`,
         declaration.moduleSpecifier,
-        this.sourceFile.fileName,
+        this.fileNameOf(declaration.moduleSpecifier),
       );
       this.markMissingModuleSymbols(declaration);
       return;
@@ -165,7 +190,7 @@ export class GeneratorContext {
       `module '${specifier}' is not supported: xbintsc can import built-in platform modules, ` +
         "relative '.ts' files and ESM packages under node_modules; CommonJS packages are not supported",
       declaration.moduleSpecifier,
-      this.sourceFile.fileName,
+      this.fileNameOf(declaration.moduleSpecifier),
     );
     for (const symbol of symbols) this.missingModuleSymbols.add(symbol.id);
   }
@@ -230,11 +255,12 @@ export class GeneratorContext {
   // -- emission primitives -------------------------------------------------
 
   emit(line: string): void {
-    this.current.buffer.push(line);
+    const location = this.debug ? this.current.debugLocation : undefined;
+    this.current.buffer.push(location === undefined ? line : `${line}, !dbg ${location}`);
   }
 
   terminate(line: string): void {
-    this.current.buffer.push(`  ${line}`);
+    this.emit(`  ${line}`);
     this.current.terminated = true;
   }
 
@@ -283,6 +309,19 @@ export class GeneratorContext {
     return ptr;
   }
 
+  /** Lay already-computed values out as a contiguous `i64*` argument buffer. */
+  emitValueArguments(values: readonly string[]): { argc: string; ptr: string } {
+    if (values.length === 0) return { argc: "0", ptr: "null" };
+    const ptr = `%args${this.current.allocas.length}`;
+    this.current.allocas.push(`${ptr} = alloca i64, i32 ${values.length}`);
+    for (let index = 0; index < values.length; index++) {
+      const slot = this.reg();
+      this.emit(`  ${slot} = getelementptr i64, i64* ${ptr}, i32 ${index}`);
+      this.emit(`  store i64 ${values[index]}, i64* ${slot}`);
+    }
+    return { argc: String(values.length), ptr };
+  }
+
   const(value: bigint): string {
     return i64(value);
   }
@@ -333,11 +372,15 @@ export class GeneratorContext {
     const slot = this.current.slots.get(symbol.id);
     if (!slot) {
       // Referenced from an inner function without a capture slot: this should
-      // be impossible once the binder has run, but stay defensive.
-      this.diagnostics.error(
-        DiagnosticCode.CodegenError,
-        `Internal: no slot for '${symbol.name}' in ${this.current.fn.name}`,
-      );
+      // be impossible once the binder has run, but stay defensive. After an
+      // unsupported construct the tree can be partially bound, so do not add
+      // an "Internal" error on top of the actionable one.
+      if (this.unsupportedCount === 0) {
+        this.diagnostics.error(
+          DiagnosticCode.CodegenError,
+          `Internal: no slot for '${symbol.name}' in ${this.current.fn.name}`,
+        );
+      }
       return i64(XT_UNDEFINED);
     }
     const value = this.reg();
@@ -362,7 +405,9 @@ export class GeneratorContext {
     }
     const slot = this.current.slots.get(symbol.id);
     if (!slot) {
-      this.diagnostics.error(DiagnosticCode.CodegenError, `Internal: no slot for '${symbol.name}'`);
+      if (this.unsupportedCount === 0) {
+        this.diagnostics.error(DiagnosticCode.CodegenError, `Internal: no slot for '${symbol.name}'`);
+      }
       return;
     }
     if (!slot.boxed) {
@@ -390,28 +435,94 @@ export class GeneratorContext {
   stringValue(text: string): string {
     const entry = this.internString(text);
     const result = this.reg();
-    this.emit(`  ${result} = call i64 @xt_string_new(i8* ${entry.label}, i64 ${entry.length})`);
+    // The value is created once in `main` and shared by every use, so a string
+    // literal (especially a property name in a hot loop) no longer allocates on
+    // each evaluation.
+    this.emit(`  ${result} = load i64, i64* ${entry.slot}`);
     return result;
   }
 
-  internString(text: string): { label: string; length: number } {
+  internString(text: string): { label: string; length: number; slot: string } {
     const existing = this.strings.get(text);
     if (existing) return existing;
-    const label = `@.str.${this.stringCounter++}`;
+    const index = this.stringCounter++;
+    const label = `@.str.${index}`;
+    const slot = `@.strv.${index}`;
     const bytes = utf8Bytes(text);
-    const entry = { label, length: bytes.length };
+    const entry = { label, length: bytes.length, slot };
     this.strings.set(text, entry);
     this.globals.push(`${label} = private unnamed_addr constant [${bytes.length + 1} x i8] c"${escapeBytes(bytes)}\\00"`);
+    // A GC-rooted global holding the runtime string value, initialised in main.
+    this.globals.push(`${slot} = internal global i64 0`);
     return entry;
   }
 
+  /**
+   * Intern a string purely as static module data (no `xt_string` value), for
+   * metadata such as shadow-stack frame names and file paths.
+   */
+  internStatic(text: string): string {
+    const existing = this.staticStrings.get(text);
+    if (existing) return existing;
+    const label = `@.meta.${this.staticCounter++}`;
+    const bytes = utf8Bytes(text);
+    this.staticStrings.set(text, label);
+    this.globals.push(`${label} = private unnamed_addr constant [${bytes.length + 1} x i8] c"${escapeBytes(bytes)}\\00"`);
+    return label;
+  }
+
+  /** Strip a bundler-generated module prefix (`m1_`) from a display name. */
+  displayNameOf(name: string): string {
+    for (const prefix of this.sourceFile.modulePrefixes ?? []) {
+      if (name.startsWith(prefix) && name.length > prefix.length) return name.slice(prefix.length);
+    }
+    return name;
+  }
+
+  /** 1-based line and column of `node` in the module it came from. */
+  positionOf(node: Node): { line: number; column: number } {
+    const file = this.fileNameOf(node);
+    const text = this.sourceFile.moduleTexts?.get(file) ?? this.sourceFile.text;
+    let starts = this.lineStartsByFile.get(file);
+    if (!starts) {
+      starts = [0];
+      for (let index = 0; index < text.length; index++) {
+        if (text.charCodeAt(index) === 10) starts.push(index + 1);
+      }
+      this.lineStartsByFile.set(file, starts);
+    }
+    const offset = Math.max(0, Math.min(node.start, text.length));
+    let low = 0;
+    let high = starts.length - 1;
+    while (low < high) {
+      const middle = (low + high + 1) >> 1;
+      if (starts[middle]! <= offset) low = middle;
+      else high = middle - 1;
+    }
+    return { line: low + 1, column: offset - starts[low]! + 1 };
+  }
+
+  /** 1-based line of `node` in the module it came from (for stack frames). */
+  lineOf(node: Node): number {
+    return this.positionOf(node).line;
+  }
+
+  /** The source file a node belongs to. Bundling merges every module into one
+   * `SourceFile` while keeping module-local offsets, so the origin map is what
+   * keeps diagnostics pointing at the file the user actually wrote.
+   */
+  fileNameOf(node: Node): string {
+    return this.sourceFile.origins?.get(node) ?? this.sourceFile.fileName;
+  }
+
   unsupported(node: Node, what: string): void {
     const label = kindName(node.kind);
+    this.unsupportedCount++;
     this.diagnostics.error(
       DiagnosticCode.UnsupportedFeature,
       `xbintsc does not yet support this ${what} (${label})`,
       node,
-      this.sourceFile.fileName,
+      this.fileNameOf(node),
     );
   }
 
@@ -429,7 +540,7 @@ export class GeneratorContext {
       DiagnosticCode.UnsupportedFeature,
       `CommonJS \`require()\` is not supported; ${replacement}`,
       node,
-      this.sourceFile.fileName,
+      this.fileNameOf(node),
     );
   }
 }

package/src/codegen/generator/debug.ts

@@ -0,0 +1,132 @@
+/**
+ * DWARF/CodeView metadata for `xbintsc build --debug`.
+ *
+ * The generated IR declares a compile unit, one `!DISubprogram` per compiled
+ * function and one cached `!DILocation` per statement position. With `-g`,
+ * clang turns these into DWARF (Linux/macOS) or CodeView (Windows), so a native
+ * debugger maps instructions back to the TypeScript source.
+ *
+ * Metadata is only emitted when debug is enabled: the nodes are large, and the
+ * default IR must stay byte-identical for the self-hosting fixpoint.
+ */
+
+import type { Node } from "../../ast/nodes.js";
+import type { FunctionInfo } from "../../binder/binder.js";
+import { escapeBytes, utf8Bytes } from "./tables.js";
+import type { Generator } from "./generator.js";
+
+export interface DebugMethods {
+  /** Allocate a numbered metadata node (`!0`, `!1`, …). */
+  metadataId(this: Generator): string;
+  /** Allocate a metadata node and register its definition. */
+  addMetadata(this: Generator, definition: string): string;
+  /** `!DIFile` for a source path, normalising separators like `source_filename`. */
+  debugFileFor(this: Generator, fileName: string): string;
+  /** `!DISubprogram` for a compiled function (created on first use). */
+  debugSubprogramFor(this: Generator, fn: FunctionInfo): string | undefined;
+  /**
+   * Point subsequent instructions at `node`'s source position. Locations are
+   * cached per function/line/column so a statement emits one metadata node
+   * instead of one per instruction.
+   */
+  setDebugLocation(this: Generator, node: Node): void;
+  /** Module-level metadata declarations and definitions (`--debug`). */
+  debugMetadataLines(this: Generator): string[];
+}
+
+function escapeMetadata(text: string): string {
+  return escapeBytes(utf8Bytes(text));
+}
+
+/**
+ * Create the compile unit and module flags once. LLVM requires the `Debug Info
+ * Version` flag for any `!dbg` attachment, and clang only emits DWARF/CodeView
+ * for a module that declares a compile unit.
+ */
+function ensureDebugUnit(self: Generator): void {
+  if (self.debugUnit !== undefined) return;
+  const entryFile = self.debugFileFor(self.sourceFile.fileName);
+  const unit = self.addMetadata(
+    'distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: ' +
+      `${entryFile}, producer: "xbintsc", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug)`,
+  );
+  self.debugUnit = unit;
+  self.debugFlags.push(
+    self.addMetadata('!{i32 7, !"Dwarf Version", i32 4}'),
+    self.addMetadata('!{i32 2, !"Debug Info Version", i32 3}'),
+  );
+  const types = self.addMetadata("!{null}");
+  self.debugSubroutineType = self.addMetadata(`!DISubroutineType(types: ${types})`);
+}
+
+export const debugMethods: DebugMethods = {
+  metadataId() {
+    return `!${this.metadataCounter++}`;
+  },
+
+  addMetadata(definition) {
+    const id = this.metadataId();
+    this.metadata.push(`${id} = ${definition}`);
+    return id;
+  },
+
+  debugFileFor(fileName) {
+    const normalized = fileName.split("\\").join("/");
+    const existing = this.debugFiles.get(normalized);
+    if (existing) return existing;
+    const slash = normalized.lastIndexOf("/");
+    const directory = slash >= 0 ? normalized.slice(0, slash) : ".";
+    const name = slash >= 0 ? normalized.slice(slash + 1) : normalized;
+    const id = this.addMetadata(
+      `!DIFile(filename: "${escapeMetadata(name)}", directory: "${escapeMetadata(directory)}")`,
+    );
+    this.debugFiles.set(normalized, id);
+    return id;
+  },
+
+  debugSubprogramFor(fn) {
+    if (!this.debug) return undefined;
+    const existing = this.debugSubprograms.get(fn.id);
+    if (existing) return existing;
+    ensureDebugUnit(this);
+    const file = this.debugFileFor(this.fileNameOf(fn.node));
+    const position = this.positionOf(fn.node);
+    const displayName = fn.isModule
+      ? "module"
+      : fn.isConstructor && fn.classInfo
+        ? `new ${this.displayNameOf(fn.classInfo.name)}`
+        : this.displayNameOf(fn.name.length > 0 ? fn.name : "anonymous");
+    const subprogram = this.addMetadata(
+      'distinct !DISubprogram(name: ' +
+        `"${escapeMetadata(displayName)}", scope: ${this.debugUnit}, file: ${file}, ` +
+        `line: ${position.line}, type: ${this.debugSubroutineType}, scopeLine: ${position.line}, ` +
+        `spFlags: DISPFlagDefinition, unit: ${this.debugUnit})`,
+    );
+    this.debugSubprograms.set(fn.id, subprogram);
+    return subprogram;
+  },
+
+  setDebugLocation(node) {
+    if (!this.debug || this.current.debugSubprogram === undefined) return;
+    const position = this.positionOf(node);
+    const key = `${this.current.debugSubprogram}:${position.line}:${position.column}`;
+    let location = this.debugLocations.get(key);
+    if (!location) {
+      location = this.addMetadata(
+        `!DILocation(line: ${position.line}, column: ${position.column}, scope: ${this.current.debugSubprogram})`,
+      );
+      this.debugLocations.set(key, location);
+    }
+    this.current.debugLocation = location;
+  },
+
+  debugMetadataLines() {
+    if (!this.debug || this.debugUnit === undefined) return [];
+    return [
+      `!llvm.dbg.cu = !{${this.debugUnit}}`,
+      `!llvm.module.flags = !{${this.debugFlags.join(", ")}}`,
+      ...this.metadata,
+      "",
+    ];
+  },
+};

package/src/codegen/generator/expressions/assignment.ts

@@ -58,9 +58,7 @@ export const assignmentExpressionMethods: AssignmentExpressionMethods = {
         this.unsupported(node, `assignment operator '${operator}'`);
         return i64(XT_UNDEFINED);
       }
-      const result = this.reg();
-      this.emit(`  ${result} = call i64 @${runtime}(i64 ${current}, i64 ${right})`);
-      value = result;
+      value = this.emitBinaryOperation(current, right, binaryOperator, runtime);
     }
     this.emitAssignmentTarget(target, value);
     return value;
@@ -120,7 +118,7 @@ export const assignmentExpressionMethods: AssignmentExpressionMethods = {
               ? `Cannot assign to '${symbol.name}' because it is an import.`
               : `Cannot assign to '${symbol.name}' because it is a constant.`,
             identifier,
-            this.sourceFile.fileName,
+            this.fileNameOf(identifier),
           );
           return;
         }
@@ -187,9 +185,13 @@ export const assignmentExpressionMethods: AssignmentExpressionMethods = {
 
   /** `{ a, b } = value` / `for ({ a } of xs)`: assign each property of `value`. */
   emitObjectAssignmentTarget(pattern: ObjectLiteralExpression, value: string): void {
+    const excludedKeys: string[] = [];
     for (const property of pattern.properties) {
       if (property.kind === SyntaxKind.SpreadElement) {
-        this.unsupported(property, "object rest destructuring");
+        const rest = this.reg();
+        const keys = this.emitValueArguments(excludedKeys);
+        this.emit(`  ${rest} = call i64 @xt_object_rest(i64 ${value}, i32 ${keys.argc}, i64* ${keys.ptr})`);
+        this.emitAssignmentTarget((property as SpreadElement).expression, rest);
         continue;
       }
       if (property.kind === SyntaxKind.PropertyAssignment) {
@@ -200,6 +202,7 @@ export const assignmentExpressionMethods: AssignmentExpressionMethods = {
         } else {
           key = this.stringValue(propertyNameText(assignment.name));
         }
+        excludedKeys.push(key);
         let target: Expression = assignment.initializer;
         let fallback: Expression | undefined;
         if (isPlainAssignment(target)) {
@@ -215,6 +218,7 @@ export const assignmentExpressionMethods: AssignmentExpressionMethods = {
       }
       const shorthand = property as ShorthandPropertyAssignment;
       const key = this.stringValue(shorthand.name.text);
+      excludedKeys.push(key);
       let elementValue = this.reg();
       this.emit(`  ${elementValue} = call i64 @xt_get(i64 ${value}, i64 ${key})`);
       if (shorthand.initializer) elementValue = this.emitBindingDefault(elementValue, shorthand.initializer);

package/src/codegen/generator/expressions/operators.ts

@@ -7,15 +7,34 @@ import {
   BinaryOperator,
   PostfixUnaryOperator,
   PrefixUnaryOperator,
+  SyntaxKind,
   type BinaryExpression,
   type ConditionalExpression,
+  type Expression,
+  type Identifier,
   type PostfixUnaryExpression,
   type PrefixUnaryExpression,
 } from "../../../ast/nodes.js";
 import { i64, numberLiteral, XT_UNDEFINED } from "../../values.js";
-import { BINARY_RUNTIME, isAssignmentOperator } from "../tables.js";
+import { BINARY_RUNTIME, BUILTIN_INSTANCEOF, isAssignmentOperator } from "../tables.js";
 import type { Generator } from "../generator.js";
 
+/** True for an expression whose value is known to be a string. */
+function isStringLike(node: Expression): boolean {
+  return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+
+/**
+ * The built-in constructor a right-hand `instanceof` operand names, if any.
+ * A user binding with the same name shadows it.
+ */
+function builtinInstanceofId(generator: Generator, expression: Expression): number | undefined {
+  if (expression.kind !== SyntaxKind.Identifier) return undefined;
+  const identifier = expression as Identifier;
+  if (generator.binding.symbolOfIdentifier.get(identifier)) return undefined;
+  return BUILTIN_INSTANCEOF[identifier.text];
+}
+
 export interface OperatorExpressionMethods {
   emitBinaryOrAssignment(this: Generator, node: BinaryExpression): string;
   emitShortCircuit(this: Generator, node: BinaryExpression, kind: "and" | "or" | "nullish"): string;
@@ -44,6 +63,17 @@ export const operatorExpressionMethods: OperatorExpressionMethods = {
       default:
         break;
     }
+    // `x instanceof Array` and friends: the built-in constructor is not a
+    // first-class value, so compare by the value's runtime kind instead.
+    if (operator === BinaryOperator.InstanceOf) {
+      const builtin = builtinInstanceofId(this, node.right);
+      if (builtin !== undefined) {
+        const leftValue = this.emitExpression(node.left);
+        const result = this.reg();
+        this.emit(`  ${result} = call i64 @xt_instance_of_builtin(i64 ${leftValue}, i32 ${builtin})`);
+        return result;
+      }
+    }
     const left = this.emitExpression(node.left);
     const right = this.emitExpression(node.right);
     const runtime = BINARY_RUNTIME[operator];
@@ -51,9 +81,10 @@ export const operatorExpressionMethods: OperatorExpressionMethods = {
       this.unsupported(node, `operator '${operator}'`);
       return i64(XT_UNDEFINED);
     }
-    const result = this.reg();
-    this.emit(`  ${result} = call i64 @${runtime}(i64 ${left}, i64 ${right})`);
-    return result;
+    // `+` concatenates when either side is known to be a string; skip the
+    // numeric tag checks for that shape and call the runtime directly.
+    const knownStringConcat = operator === "+" && (isStringLike(node.left) || isStringLike(node.right));
+    return this.emitBinaryOperation(left, right, operator, runtime, !knownStringConcat);
   },
 
   emitShortCircuit(node: BinaryExpression, kind: "and" | "or" | "nullish"): string {
@@ -159,8 +190,12 @@ export const operatorExpressionMethods: OperatorExpressionMethods = {
         const one = numberLiteral(1);
         const current = this.emitExpression(node.operand);
         const fn = node.operator === PrefixUnaryOperator.PlusPlus ? "xt_add" : "xt_sub";
-        const next = this.reg();
-        this.emit(`  ${next} = call i64 @${fn}(i64 ${current}, i64 ${one})`);
+        const next = this.emitBinaryOperation(
+          current,
+          one,
+          node.operator === PrefixUnaryOperator.PlusPlus ? "+" : "-",
+          fn,
+        );
         this.emitAssignmentTarget(node.operand, next);
         return next;
       }
@@ -174,8 +209,12 @@ export const operatorExpressionMethods: OperatorExpressionMethods = {
     const one = numberLiteral(1);
     const current = this.emitExpression(node.operand);
     const fn = node.operator === PostfixUnaryOperator.PlusPlus ? "xt_add" : "xt_sub";
-    const next = this.reg();
-    this.emit(`  ${next} = call i64 @${fn}(i64 ${current}, i64 ${one})`);
+    const next = this.emitBinaryOperation(
+      current,
+      one,
+      node.operator === PostfixUnaryOperator.PlusPlus ? "+" : "-",
+      fn,
+    );
     this.emitAssignmentTarget(node.operand, next);
     return current;
   },

package/src/codegen/generator/expressions/primary.ts

@@ -193,7 +193,7 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
           DiagnosticCode.CodegenError,
           `Imported binding '${identifier.text}' cannot be used as a value`,
           identifier,
-          this.sourceFile.fileName,
+          this.fileNameOf(identifier),
         );
         return i64(XT_UNDEFINED);
       }
@@ -244,7 +244,7 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
           DiagnosticCode.CannotFindName,
           `Cannot find name '${identifier.text}'`,
           identifier,
-          this.sourceFile.fileName,
+          this.fileNameOf(identifier),
         );
         return i64(XT_UNDEFINED);
       }
@@ -292,6 +292,9 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
 
   emitNew(node: NewExpression): string {
     const callee = node.expression;
+    // A `new` expression is where the innermost frame's line should point for
+    // `Error.stack`; harmless for every other constructor.
+    this.emit(`  call void @xt_stack_set_line(i32 ${this.lineOf(node)})`);
     if (callee.kind === SyntaxKind.Identifier) {
       const identifier = callee as Identifier;
       const symbol = this.binding.symbolOfIdentifier.get(identifier);

package/src/codegen/generator/generator.ts

@@ -14,13 +14,29 @@ import { moduleMethods, type ModuleMethods } from "./module.js";
 import { statementMethods, type StatementMethods } from "./statements.js";
 import { expressionMethods, type ExpressionMethods } from "./expressions.js";
 import { callMethods, type CallMethods } from "./calls.js";
+import { numericMethods, type NumericMethods } from "./numeric.js";
+import { debugMethods, type DebugMethods } from "./debug.js";
 import type { CodegenOptions, CodegenResult } from "./state.js";
 
 export class Generator extends GeneratorContext {}
 
-export interface Generator extends ModuleMethods, StatementMethods, ExpressionMethods, CallMethods {}
+export interface Generator
+  extends ModuleMethods,
+    StatementMethods,
+    ExpressionMethods,
+    CallMethods,
+    NumericMethods,
+    DebugMethods {}
 
-Object.assign(Generator.prototype, moduleMethods, statementMethods, expressionMethods, callMethods);
+Object.assign(
+  Generator.prototype,
+  moduleMethods,
+  statementMethods,
+  expressionMethods,
+  callMethods,
+  numericMethods,
+  debugMethods,
+);
 
 export type { CodegenOptions, CodegenResult } from "./state.js";