xbintsc 0.1.8 → 0.1.9

package/src/binder/binder.ts

@@ -9,14 +9,21 @@
  * cached, serialized for the incremental build, and unit tested in isolation.
  */
 
+import { NodeFlags, ModifierKind } from "../ast/kinds.js";
 import {
   SyntaxKind,
   type ArrowFunction,
   type Block,
+  type ClassDeclaration,
+  type ClassExpression,
+  type ConstructorDeclaration,
   type FunctionDeclaration,
   type FunctionExpression,
   type Identifier,
+  type MethodDeclaration,
   type Node,
+  type PropertyDeclaration,
+  type PropertyName,
   type SourceFileNode,
   type Statement,
   type Expression,
@@ -76,6 +83,40 @@ export interface FunctionInfo {
   readonly captureIndex: Map<number, number>;
   readonly isModule: boolean;
   readonly isArrow: boolean;
+  /** True when the function was declared `async`. */
+  readonly isAsync: boolean;
+  /** True when this function's body mentions `this` directly. */
+  usesThis: boolean;
+  /** True when an arrow function must receive `this` from its enclosing scope. */
+  capturesThis: boolean;
+  /** Set for class methods/constructors; carries the owning class. */
+  classInfo?: ClassInfo;
+  /** True for `static` class members. */
+  isStatic?: boolean;
+  /** True for an explicit `constructor`. */
+  isConstructor?: boolean;
+}
+
+export interface ClassInfo {
+  readonly id: number;
+  readonly name: string;
+  readonly node: Node;
+  readonly scope: Scope;
+  readonly parent?: ClassInfo;
+  readonly parentExpression?: Expression;
+  /** `this`-bearing fields declared on the class. */
+  readonly fields: ClassFieldInfo[];
+  readonly methods: FunctionInfo[];
+  readonly statics: FunctionInfo[];
+  ctor?: FunctionInfo;
+  /** The symbol the class name binds to, when there is one. */
+}
+
+export interface ClassFieldInfo {
+  readonly name: string;
+  readonly initializer: Expression | undefined;
+  readonly fn: FunctionInfo;
+  readonly isStatic: boolean;
 }
 
 export enum ScopeKind {
@@ -98,6 +139,9 @@ export interface Scope {
 export interface BindResult {
   readonly moduleFunction: FunctionInfo;
   readonly functions: FunctionInfo[];
+  readonly classes: ClassInfo[];
+  /** Maps a class-like AST node to the ClassInfo the binder built. */
+  readonly classOfNode: Map<Node, ClassInfo>;
   /** Maps a function-like AST node to the FunctionInfo the binder built for it. */
   readonly functionOfNode: Map<Node, FunctionInfo>;
   readonly symbolOfDeclaration: Map<Node, SymbolInfo>;
@@ -120,12 +164,15 @@ export function bind(sourceFile: SourceFileNode): BindResult {
 
 class Binder {
   private readonly functions: FunctionInfo[] = [];
+  private readonly classes: ClassInfo[] = [];
+  private readonly classOfNode = new Map<Node, ClassInfo>();
   private readonly symbolOfDeclaration = new Map<Node, SymbolInfo>();
   private readonly symbolOfIdentifier = new Map<Identifier, SymbolInfo>();
   private readonly scopes = new Map<Node, Scope>();
   private readonly unresolved: Identifier[] = [];
   private nextSymbolId = 1;
   private nextFunctionId = 1;
+  private nextClassId = 1;
   private current!: MutableFunction;
 
   constructor(private readonly sourceFile: SourceFileNode) {}
@@ -140,9 +187,22 @@ class Binder {
     this.collectFunctionScoped(this.sourceFile.statements, this.current);
     this.bindStatements(this.sourceFile.statements, scope);
 
+    // Arrows inherit `this` lexically: propagate the need to capture it up the
+    // chain of arrow functions until reaching a regular function.
+    for (let index = this.functions.length - 1; index >= 0; index--) {
+      const fn = this.functions[index]! as MutableFunction;
+      if (fn.usesThis && fn.isArrow) {
+        fn.capturesThis = true;
+        const parent = fn.parent as MutableFunction | undefined;
+        if (parent && parent.isArrow) parent.usesThis = true;
+      }
+    }
+
     return {
       moduleFunction: this.current,
       functions: this.functions,
+      classes: this.classes,
+      classOfNode: this.classOfNode,
       functionOfNode: new Map(this.functions.map((fn) => [fn.node as Node, fn])),
       symbolOfDeclaration: this.symbolOfDeclaration,
       symbolOfIdentifier: this.symbolOfIdentifier,
@@ -172,6 +232,9 @@ class Binder {
       captureIndex: new Map(),
       isModule,
       isArrow,
+      isAsync: (((node as { flags?: number }).flags ?? 0) & NodeFlags.Async) !== 0,
+      usesThis: false,
+      capturesThis: false,
     };
     this.functions.push(fn);
     return fn;
@@ -369,6 +432,13 @@ class Binder {
       case SyntaxKind.Identifier:
         this.reference(node as Identifier, scope);
         return;
+      case SyntaxKind.ThisKeyword:
+        this.current.usesThis = true;
+        return;
+      case SyntaxKind.ClassDeclaration:
+      case SyntaxKind.ClassExpression:
+        this.bindClass(node as ClassDeclaration | ClassExpression, scope);
+        return;
       case SyntaxKind.InterfaceDeclaration:
       case SyntaxKind.TypeAliasDeclaration:
         // Type-only: skip the body entirely.
@@ -490,7 +560,118 @@ class Binder {
     this.current = parentFn;
   }
 
+  private bindClass(node: ClassDeclaration | ClassExpression, scope: Scope): void {
+    const parentFn = this.current;
+    const name = node.name ? node.name.text : "(anonymous)";
+
+    let parentExpression: Expression | undefined;
+    let parentClass: ClassInfo | undefined;
+    const heritage = node.heritage.find((clause) => clause.token === "extends");
+    if (heritage && heritage.types.length > 0) {
+      parentExpression = heritage.types[0]!.expression;
+      this.bindNode(parentExpression, scope);
+      if (parentExpression.kind === SyntaxKind.Identifier) {
+        const symbol = this.symbolOfIdentifier.get(parentExpression as Identifier);
+        const declaration = symbol?.declarations[0];
+        if (declaration) parentClass = this.classOfNode.get(declaration);
+      }
+    }
+
+    const info: ClassInfo = {
+      id: this.nextClassId++,
+      name,
+      node,
+      scope,
+      parent: parentClass,
+      parentExpression,
+      fields: [],
+      methods: [],
+      statics: [],
+    };
+    this.classes.push(info);
+    this.classOfNode.set(node, info);
+
+    const classScope = this.createScope(ScopeKind.Block, node, scope);
+    this.scopes.set(node, classScope);
+
+    let constructor: FunctionInfo | undefined;
+    for (const member of node.members) {
+      if (member.kind === SyntaxKind.ConstructorDeclaration) {
+        const ctor = member as ConstructorDeclaration;
+        constructor = this.createClassFunction(ctor, "constructor", ctor.parameters, ctor.body, classScope, info, false, true);
+      } else if (member.kind === SyntaxKind.MethodDeclaration) {
+        const method = member as MethodDeclaration;
+        const isStatic = method.modifiers.some((modifier) => modifier.modifierKind === ModifierKind.Static);
+        const fn = this.createClassFunction(method, classMemberName(method.name), method.parameters, method.body, classScope, info, isStatic, false);
+        if (isStatic) (info.statics as FunctionInfo[]).push(fn);
+        else (info.methods as FunctionInfo[]).push(fn);
+      }
+    }
+    if (!constructor) {
+      constructor = this.createClassFunction(node, "constructor", [], undefined, classScope, info, false, true);
+    }
+    info.ctor = constructor;
+
+    // Field initializers run in the constructor's context so they can capture
+    // enclosing variables.
+    for (const member of node.members) {
+      if (member.kind === SyntaxKind.PropertyDeclaration) {
+        const property = member as PropertyDeclaration;
+        const isStatic = property.modifiers.some((modifier) => modifier.modifierKind === ModifierKind.Static);
+        const owner = this.current;
+        this.current = constructor as MutableFunction;
+        if (property.initializer) this.bindNode(property.initializer, classScope);
+        this.current = owner;
+        info.fields.push({ name: classMemberName(property.name), initializer: property.initializer, fn: constructor, isStatic });
+      }
+    }
+
+    this.current = parentFn;
+  }
+
+  private createClassFunction(
+    member: Node,
+    name: string,
+    parameters: readonly import("../ast/declarations.js").Parameter[],
+    body: Block | undefined,
+    parentScope: Scope,
+    info: ClassInfo,
+    isStatic: boolean,
+    isConstructor: boolean,
+  ): FunctionInfo {
+    const parentFn = this.current;
+    const fn = this.createFunction(name, member as unknown as FunctionNode, parentFn, false, false);
+    (fn as MutableFunction & { classInfo: ClassInfo }).classInfo = info;
+    (fn as MutableFunction & { isStatic: boolean }).isStatic = isStatic;
+    (fn as MutableFunction & { isConstructor: boolean }).isConstructor = isConstructor;
+    this.current = fn as MutableFunction;
+    const scope = this.createScope(ScopeKind.Function, member, parentScope);
+    (fn as { scope: Scope }).scope = scope;
+    this.scopes.set(member, scope);
+
+    const params: SymbolInfo[] = [];
+    for (const parameter of parameters) {
+      const paramSymbol = this.declare(parameter.name.text, SymbolKind.Parameter, parameter, scope, true);
+      params.push(paramSymbol);
+      if (parameter.initializer) this.bindNode(parameter.initializer, scope);
+    }
+    (fn as { params: SymbolInfo[] }).params = params;
+
+    if (body) {
+      this.collectFunctionScoped([body], fn as MutableFunction);
+      this.predeclareStatements(body.statements, scope);
+      this.bindStatements(body.statements, scope);
+    }
+
+    this.current = parentFn;
+    return fn;
+  }
+
   private reference(identifier: Identifier, scope: Scope): void {
+    if (identifier.text === "super") {
+      this.current.usesThis = true;
+      return;
+    }
     let current: Scope | undefined = scope;
     while (current) {
       const symbol = current.symbols.get(identifier.text);
@@ -547,3 +728,18 @@ function isCapturable(kind: SymbolKind): boolean {
     kind === SymbolKind.Parameter
   );
 }
+
+/** Extract the textual name of a class member (`method`, `"key"`, `0`). */
+function classMemberName(name: PropertyName): string {
+  switch (name.kind) {
+    case SyntaxKind.Identifier:
+    case SyntaxKind.PrivateIdentifier:
+      return (name as unknown as { text: string }).text;
+    case SyntaxKind.StringLiteral:
+      return (name as unknown as { value: string }).value;
+    case SyntaxKind.NumericLiteral:
+      return String((name as unknown as { value: number }).value);
+    default:
+      return "";
+  }
+}

package/src/codegen/generator/calls.ts

@@ -15,14 +15,16 @@ import {
   type ObjectLiteralExpression,
   type PropertyAccessExpression,
 } from "../../ast/nodes.js";
-import { SymbolKind } from "../../binder/binder.js";
+import { SymbolKind, type FunctionInfo } from "../../binder/binder.js";
 import { i64, numberLiteral, XT_TRUE, XT_UNDEFINED } from "../values.js";
 import {
   BUILTIN_METHODS,
   CONSOLE_METHODS,
+  CTOR_FUNCTIONS,
   GLOBAL_FUNCTIONS,
   MATH_CONSTANTS,
   MATH_FUNCTIONS,
+  NAMESPACE_STATICS,
   propertyNameText,
 } from "./tables.js";
 import type { Generator } from "./generator.js";
@@ -39,6 +41,9 @@ export interface CallMethods {
   emitArrayLiteral(this: Generator, node: ArrayLiteralExpression): string;
   emitObjectLiteral(this: Generator, node: ObjectLiteralExpression): string;
   emitClosure(this: Generator, node: ArrowFunction | FunctionExpression): string;
+  emitClosureValue(this: Generator, fn: FunctionInfo): string;
+  emitSuperConstructor(this: Generator, node: CallExpression): string;
+  emitSuperCall(this: Generator, node: CallExpression, access: PropertyAccessExpression): string;
 }
 
 export const callMethods: CallMethods = {
@@ -76,10 +81,30 @@ export const callMethods: CallMethods = {
       });
     }
     if (callee.kind === SyntaxKind.PropertyAccessExpression) {
-      const special = this.tryEmitBuiltinCall(node, callee as PropertyAccessExpression);
+      const access = callee as PropertyAccessExpression;
+      const special = this.tryEmitBuiltinCall(node, access);
       if (special) return special;
+      if (access.expression.kind === SyntaxKind.Identifier && (access.expression as Identifier).text === "super") {
+        return this.emitSuperCall(node, access);
+      }
+      const object = this.emitExpression(access.expression);
+      const name = this.stringValue(access.name.text);
+      const args = this.emitArguments(node.arguments);
+      const result = this.reg();
+      this.emit(`  ${result} = call i64 @xt_call_method(i64 ${object}, i64 ${name}, i32 ${args.argc}, i64* ${args.ptr})`);
+      return result;
+    }
+    if (callee.kind === SyntaxKind.ElementAccessExpression) {
+      const access = callee as ElementAccessExpression;
+      const object = this.emitExpression(access.expression);
+      const name = this.emitExpression(access.argumentExpression);
+      const args = this.emitArguments(node.arguments);
+      const result = this.reg();
+      this.emit(`  ${result} = call i64 @xt_call_method(i64 ${object}, i64 ${name}, i32 ${args.argc}, i64* ${args.ptr})`);
+      return result;
     }
     if (callee.kind === SyntaxKind.Identifier) {
+      if ((callee as Identifier).text === "super") return this.emitSuperConstructor(node);
       const symbol = this.binding.symbolOfIdentifier.get(callee as Identifier);
       if (symbol && symbol.kind === SymbolKind.Function) {
         const declaration = symbol.declarations[0];
@@ -88,7 +113,7 @@ export const callMethods: CallMethods = {
           const args = this.emitArguments(node.arguments);
           const result = this.reg();
           this.emit(
-            `  ${result} = call i64 @${this.functionName(fn)}(i64 ${i64(XT_UNDEFINED)}, i32 ${args.argc}, i64* ${args.ptr})`,
+            `  ${result} = call i64 @${this.functionName(fn)}(i64 ${i64(XT_UNDEFINED)}, i64 ${i64(XT_UNDEFINED)}, i32 ${args.argc}, i64* ${args.ptr})`,
           );
           return result;
         }
@@ -114,6 +139,13 @@ export const callMethods: CallMethods = {
         this.emit(`  ${result} = call i64 @${builtin.symbol}(i32 ${args.argc}, i64* ${args.ptr})`);
         return result;
       }
+      const ctor = !symbol ? CTOR_FUNCTIONS[(callee as Identifier).text] : undefined;
+      if (ctor) {
+        const args = this.emitArguments(node.arguments);
+        const result = this.reg();
+        this.emit(`  ${result} = call i64 @${ctor}(i32 ${args.argc}, i64* ${args.ptr})`);
+        return result;
+      }
     }
     const calleeValue = this.emitExpression(callee);
     const args = this.emitArguments(node.arguments);
@@ -147,31 +179,27 @@ export const callMethods: CallMethods = {
       return result;
     }
 
-    if (targetIdentifier && targetIdentifier.text === "Object" && !targetSymbol) {
-      if (method === "keys" || method === "values" || method === "entries") {
-        const argument = node.arguments.length > 0 ? this.emitExpression(node.arguments[0]!) : i64(XT_UNDEFINED);
-        const fn = method === "keys" ? "xt_object_keys" : method === "values" ? "xt_object_values" : "xt_object_entries";
-        return this.runtimeCall(fn, [argument]);
-      }
-      if (method === "assign") {
+    if (targetIdentifier && targetIdentifier.text === "JSON" && !targetSymbol) {
+      const fn = method === "parse" ? "xt_json_parse" : method === "stringify" ? "xt_json_stringify" : undefined;
+      if (!fn) return undefined;
+      const args = this.emitArguments(node.arguments);
+      const result = this.reg();
+      this.emit(`  ${result} = call i64 @${fn}(i32 ${args.argc}, i64* ${args.ptr})`);
+      return result;
+    }
+
+    if (targetIdentifier && !targetSymbol) {
+      const dispatcher = NAMESPACE_STATICS[targetIdentifier.text];
+      if (dispatcher && targetIdentifier.text !== "Math" && targetIdentifier.text !== "JSON") {
+        const name = this.stringValue(method);
         const args = this.emitArguments(node.arguments);
         const result = this.reg();
-        this.emit(`  ${result} = call i64 @xt_object_assign(i32 ${args.argc}, i64* ${args.ptr})`);
+        this.emit(`  ${result} = call i64 @${dispatcher}(i64 ${name}, i32 ${args.argc}, i64* ${args.ptr})`);
         return result;
       }
-      return undefined;
     }
 
-    if (BUILTIN_METHODS.has(method)) {
-      const object = this.emitExpression(target);
-      const name = this.stringValue(method);
-      const args = this.emitArguments(node.arguments);
-      const result = this.reg();
-      this.emit(
-        `  ${result} = call i64 @xt_call_method(i64 ${object}, i64 ${name}, i32 ${args.argc}, i64* ${args.ptr})`,
-      );
-      return result;
-    }
+    void BUILTIN_METHODS;
     return undefined;
   },
 
@@ -212,6 +240,17 @@ export const callMethods: CallMethods = {
   },
 
   emitPropertyAccess(node: PropertyAccessExpression): string {
+    if (node.expression.kind === SyntaxKind.Identifier && (node.expression as Identifier).text === "super") {
+      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(node.name.text);
+      const value = this.reg();
+      this.emit(`  ${value} = call i64 @xt_get(i64 ${parentProto}, i64 ${key})`);
+      return value;
+    }
     if (
       node.name.text in MATH_CONSTANTS &&
       node.expression.kind === SyntaxKind.Identifier &&
@@ -323,33 +362,72 @@ export const callMethods: CallMethods = {
       this.unsupported(node, "closure");
       return i64(XT_UNDEFINED);
     }
+    return this.emitClosureValue(fn);
+  },
+
+  emitClosureValue(fn: FunctionInfo): string {
+    const count = fn.captures.length + (fn.capturesThis ? 1 : 0);
     let envPtr = "null";
-    if (fn.captures.length > 0) {
+    if (count > 0) {
       envPtr = `%env${this.current.allocas.length}`;
-      this.current.allocas.push(`${envPtr} = alloca i64, i32 ${fn.captures.length}`);
+      this.current.allocas.push(`${envPtr} = alloca i64, i32 ${count}`);
       for (let index = 0; index < fn.captures.length; index++) {
         const symbol = fn.captures[index]!;
-        // The current function must be able to read the capture: either from
-        // its own slot (local) or from one of its own capture slots.
         const slot = this.current.slots.get(symbol.id);
-        let raw: string;
+        let raw = i64(XT_UNDEFINED);
         if (slot) {
           raw = this.reg();
           this.emit(`  ${raw} = load i64, i64* ${slot.ptr}`);
-        } else {
-          const outer = this.binding.functionOfNode.get(node);
-          void outer;
-          raw = i64(XT_UNDEFINED);
         }
         const target = this.reg();
         this.emit(`  ${target} = getelementptr i64, i64* ${envPtr}, i32 ${index}`);
         this.emit(`  store i64 ${raw}, i64* ${target}`);
       }
+      if (fn.capturesThis) {
+        let thisValue = i64(XT_UNDEFINED);
+        if (this.current.thisPtr) {
+          thisValue = this.reg();
+          this.emit(`  ${thisValue} = load i64, i64* ${this.current.thisPtr}`);
+        }
+        const target = this.reg();
+        this.emit(`  ${target} = getelementptr i64, i64* ${envPtr}, i32 ${fn.captures.length}`);
+        this.emit(`  store i64 ${thisValue}, i64* ${target}`);
+      }
     }
     const cast = this.reg();
-    this.emit(`  ${cast} = bitcast i64 (i64, i32, i64*)* @${this.functionName(fn)} to i8*`);
+    this.emit(`  ${cast} = bitcast i64 (i64, i64, i32, i64*)* @${this.functionName(fn)} to i8*`);
     const closure = this.reg();
-    this.emit(`  ${closure} = call i64 @xt_closure_new(i8* ${cast}, i32 ${fn.captures.length}, i64* ${envPtr})`);
+    this.emit(`  ${closure} = call i64 @xt_closure_new(i8* ${cast}, i32 ${count}, i64* ${envPtr})`);
     return closure;
   },
+
+  emitSuperConstructor(node: CallExpression): 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("__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;
+  },
 };

package/src/codegen/generator/context.ts

@@ -6,7 +6,7 @@
  * helpers every group relies on.
  */
 
-import { bind, type BindResult, type SymbolInfo } from "../../binder/binder.js";
+import { bind, type BindResult, type ClassInfo, type SymbolInfo } from "../../binder/binder.js";
 import type { DiagnosticBag } from "../../diagnostics/diagnostic.js";
 import { DiagnosticCode } from "../../diagnostics/diagnostic.js";
 import type { SourceFileNode, Node } from "../../ast/nodes.js";
@@ -23,6 +23,8 @@ export class GeneratorContext {
   readonly globals: string[] = [];
   readonly functions: string[] = [];
   readonly strings = new Map<string, { label: string; length: number }>();
+  readonly classGlobals = new Map<number, string>();
+  readonly moduleGlobals = new Map<number, string>();
   readonly extraDeclarations = new Set<string>();
   stringCounter = 0;
   current!: FunctionState;
@@ -72,6 +74,18 @@ export class GeneratorContext {
   // -- variables -----------------------------------------------------------
 
   declareSlot(symbol: SymbolInfo, initial: string): void {
+    const globalName = this.moduleGlobals.get(symbol.id);
+    if (globalName) {
+      if (symbol.boxed) {
+        const box = this.reg();
+        this.emit(`  ${box} = call i64 @xt_box_new(i64 ${initial})`);
+        this.emit(`  store i64 ${box}, i64* ${globalName}`);
+      } else {
+        this.emit(`  store i64 ${initial}, i64* ${globalName}`);
+      }
+      this.current.slots.set(symbol.id, { ptr: globalName, boxed: symbol.boxed });
+      return;
+    }
     const ptr = this.alloca();
     if (symbol.boxed) {
       const box = this.reg();
@@ -91,6 +105,15 @@ export class GeneratorContext {
   }
 
   readSlot(symbol: SymbolInfo): string {
+    const globalName = this.moduleGlobals.get(symbol.id);
+    if (globalName) {
+      const value = this.reg();
+      this.emit(`  ${value} = load i64, i64* ${globalName}`);
+      if (!symbol.boxed) return value;
+      const unboxed = this.reg();
+      this.emit(`  ${unboxed} = call i64 @xt_box_get(i64 ${value})`);
+      return unboxed;
+    }
     const slot = this.current.slots.get(symbol.id);
     if (!slot) {
       // Referenced from an inner function without a capture slot: this should
@@ -110,6 +133,17 @@ export class GeneratorContext {
   }
 
   writeSlot(symbol: SymbolInfo, value: string): void {
+    const globalName = this.moduleGlobals.get(symbol.id);
+    if (globalName) {
+      if (!symbol.boxed) {
+        this.emit(`  store i64 ${value}, i64* ${globalName}`);
+        return;
+      }
+      const box = this.reg();
+      this.emit(`  ${box} = load i64, i64* ${globalName}`);
+      this.emit(`  call i64 @xt_box_set(i64 ${box}, i64 ${value})`);
+      return;
+    }
     const slot = this.current.slots.get(symbol.id);
     if (!slot) {
       this.diagnostics.error(DiagnosticCode.CodegenError, `Internal: no slot for '${symbol.name}'`);