xbintsc 0.2.5 → 0.2.6

package/src/codegen/generator/state.ts

@@ -68,6 +68,8 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "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_object_define_getter(i64, i64, i64)",
+  "declare i64 @xt_object_define_setter(i64, i64, i64)",
   "declare i64 @xt_await(i64)",
   "declare void @xt_drain_microtasks()",
   "declare void @xt_run_event_loop()",
@@ -102,6 +104,7 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_date_ctor(i32, i64*)",
   "declare i64 @xt_regexp_ctor(i32, i64*)",
   "declare i64 @xt_error_ctor(i32, i64*)",
+  "declare i64 @xt_error_init(i64, i32, i64*)",
   "declare i64 @xt_json_parse(i32, i64*)",
   "declare i64 @xt_json_stringify(i32, i64*)",
   "declare i64 @xt_object_from_entries(i64)",
@@ -169,10 +172,22 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_delete(i64, i64)",
   "declare i64 @xt_rest_args(i32, i64*, i32)",
   "declare void @xt_set_program_args(i32, i8**)",
+  "declare i64 @xt_import_meta(i64)",
   "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_iter_length(i64)",
+  "declare i64 @xt_iter_value(i64, i64)",
+  "declare i32 @xt_array_size(i64)",
+  "declare i64* @xt_array_items(i64)",
+  "declare i64 @xt_builtin_value_parseInt(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_parseFloat(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_isNaN(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_isFinite(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_number(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_string(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_boolean(i64, i64, i32, i64*)",
   "declare i64 @xt_get(i64, i64)",
   "declare i64 @xt_set(i64, i64, i64)",
   "declare i64 @xt_box_new(i64)",

package/src/codegen/generator/statements.ts

@@ -143,15 +143,31 @@ export const statementMethods: StatementMethods = {
 
   emitVariableStatement(statement: VariableStatement): void {
     for (const declaration of statement.declarationList.declarations) {
-      const initial = declaration.initializer
-        ? this.emitExpression(declaration.initializer)
-        : i64(XT_UNDEFINED);
       if (declaration.name.kind === SyntaxKind.Identifier) {
         const symbol = this.binding.symbolOfDeclaration.get(declaration);
-        if (!symbol) continue;
-        if (this.current.slots.has(symbol.id)) continue; // hoisted `var`
+        if (!symbol) {
+          if (declaration.initializer) this.emitExpression(declaration.initializer);
+          continue;
+        }
+        if (this.current.slots.has(symbol.id)) {
+          // Hoisted `var` (or an already-declared slot): keep evaluating the
+          // initializer for its side effects, but do not redeclare the slot.
+          if (declaration.initializer) this.emitExpression(declaration.initializer);
+          continue;
+        }
+        if (symbol.boxed) {
+          // A captured binding lives in a box. Create the box *before*
+          // evaluating the initializer so a self-referencing closure
+          // (`const f = () => f()`) captures the box, not a copy of the
+          // still-uninitialised value.
+          this.declareSlot(symbol, i64(XT_UNDEFINED));
+          if (declaration.initializer) this.writeSlot(symbol, this.emitExpression(declaration.initializer));
+          continue;
+        }
+        const initial = declaration.initializer ? this.emitExpression(declaration.initializer) : i64(XT_UNDEFINED);
         this.declareSlot(symbol, initial);
       } else {
+        const initial = declaration.initializer ? this.emitExpression(declaration.initializer) : i64(XT_UNDEFINED);
         this.emitBindingPattern(declaration.name, initial);
       }
     }
@@ -287,7 +303,6 @@ export const statementMethods: StatementMethods = {
     const nonzero = this.reg();
     this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
     this.terminate(`br i1 ${nonzero}, label %${bodyLabel}, label %${endLabel}`);
-
     this.startBlock(bodyLabel);
     this.current.loops.push({ breakLabel: endLabel, continueLabel: condLabel, tryDepth: this.current.tryFrames.length });
     this.emitStatement(statement.statement);
@@ -369,7 +384,7 @@ export const statementMethods: StatementMethods = {
     const indexPtr = this.alloca();
     this.emit(`  store i64 ${numberLiteral(0)}, i64* ${indexPtr}`);
     const lengthValue = this.reg();
-    this.emit(`  ${lengthValue} = call i64 @xt_array_length(i64 ${iterable})`);
+    this.emit(`  ${lengthValue} = call i64 @xt_iter_length(i64 ${iterable})`);
 
     const condLabel = this.label("forof.cond");
     const bodyLabel = this.label("forof.body");
@@ -390,7 +405,7 @@ export const statementMethods: StatementMethods = {
 
     this.startBlock(bodyLabel);
     const element = this.reg();
-    this.emit(`  ${element} = call i64 @xt_get(i64 ${iterable}, i64 ${index})`);
+    this.emit(`  ${element} = call i64 @xt_iter_value(i64 ${iterable}, i64 ${index})`);
     this.bindLoopVariable(statement.initializer, element);
     this.current.loops.push({ breakLabel: endLabel, continueLabel: updateLabel, tryDepth: this.current.tryFrames.length });
     this.emitStatement(statement.statement);

package/src/codegen/generator/tables.ts

@@ -79,6 +79,18 @@ export const GLOBAL_FUNCTIONS: Record<string, string> = {
   Boolean: "xt_boolean_ctor",
 };
 
+/** Global functions that are also usable as first-class values, each mapped to
+ * a runtime trampoline with the closure ABI. */
+export const BUILTIN_FUNCTION_VALUES: Record<string, string> = {
+  parseInt: "xt_builtin_value_parseInt",
+  parseFloat: "xt_builtin_value_parseFloat",
+  isNaN: "xt_builtin_value_isNaN",
+  isFinite: "xt_builtin_value_isFinite",
+  Number: "xt_builtin_value_number",
+  String: "xt_builtin_value_string",
+  Boolean: "xt_builtin_value_boolean",
+};
+
 /** Global namespaces whose static methods map to runtime dispatchers. */
 export const NAMESPACE_STATICS: Record<string, string> = {
   Math: "xt_math_call",
@@ -107,6 +119,7 @@ export const NAMESPACE_STATICS: Record<string, string> = {
 /** Namespace identifiers whose property access maps to a runtime getter. */
 export const NAMESPACE_PROPERTIES: Record<string, string> = {
   process: "xt_process_get",
+  "import.meta": "xt_import_meta",
 };
 
 /** Global constructors called as `new X(...)` (all have signature `(i32, i64*)`). */

package/src/codegen/values.ts

@@ -5,32 +5,101 @@
  * value uses a tag in the high 16 bits plus a 48-bit payload. The compiler
  * emits these constants directly into LLVM IR, so this module (together with
  * runtime/rt.h) is the single source of truth for the representation.
+ *
+ * The constants are written as pre-computed signed 64-bit decimal literals
+ * rather than BigInt expressions, and `numberLiteral` derives the raw bits of a
+ * double with plain arithmetic. That keeps this module free of BigInt and
+ * typed-array APIs so the compiler can be compiled by itself on every platform.
  */
 
-export const XT_TAG_MASK = 0xffff000000000000n;
-export const XT_NUMBER_MASK = 0xfff8000000000000n;
+/** `0xffff000000000000` as a signed i64. */
+export const XT_TAG_MASK = "-281474976710656";
+/** `0xfff8000000000000` as a signed i64. */
+export const XT_NUMBER_MASK = "-2251799813685248";
 
-export const XT_UNDEFINED = 0xfff8000000000000n;
-export const XT_NULL = 0xfff9000000000000n;
-export const XT_FALSE = 0xfffa000000000000n;
-export const XT_TRUE = 0xfffb000000000000n;
-export const XT_STRING = 0xfffc000000000000n;
-export const XT_OBJECT = 0xfffd000000000000n;
-export const XT_ARRAY = 0xfffe000000000000n;
-export const XT_FUNCTION = 0xffff000000000000n;
+export const XT_UNDEFINED = "-2251799813685248"; // 0xfff8000000000000
+export const XT_NULL = "-1970324836974592"; // 0xfff9000000000000
+export const XT_FALSE = "-1688849860263936"; // 0xfffa000000000000
+export const XT_TRUE = "-1407374883553280"; // 0xfffb000000000000
+export const XT_STRING = "-1125899906842624"; // 0xfffc000000000000
+export const XT_OBJECT = "-844424930131968"; // 0xfffd000000000000
+export const XT_ARRAY = "-562949953421312"; // 0xfffe000000000000
+export const XT_FUNCTION = "-281474976710656"; // 0xffff000000000000
 
 /** Render a 64-bit constant the way LLVM expects signed i64 literals. */
-export function i64(value: bigint): string {
-  return BigInt.asIntN(64, value).toString();
+export function i64(value: string): string {
+  return value;
 }
 
 /** The raw 64 bits of an IEEE-754 double, as a signed i64 literal. */
 export function numberLiteral(value: number): string {
-  const view = new DataView(new ArrayBuffer(8));
-  view.setFloat64(0, value);
-  return i64(view.getBigInt64(0));
+  if (value !== value) return "9221120237041090560"; // 0x7ff8000000000000 (NaN)
+  const negative = value < 0 || (value === 0 && 1 / value < 0);
+  const abs = negative ? -value : value;
+  let high: number;
+  let low: number;
+  if (abs === 0) {
+    high = 0;
+    low = 0;
+  } else if (abs === Infinity) {
+    high = 0x7ff00000;
+    low = 0;
+  } else {
+    let exponent = Math.floor(Math.log2(abs));
+    while (exponent < 1023 && Math.pow(2, exponent + 1) <= abs) exponent++;
+    while (exponent > -1022 && Math.pow(2, exponent) > abs) exponent--;
+    let mantissa = Math.round((abs / Math.pow(2, exponent) - 1) * 4503599627370496);
+    let biased = exponent + 1023;
+    if (biased <= 0) {
+      mantissa = Math.round((abs / Math.pow(2, -1022)) * 4503599627370496);
+      biased = 0;
+    } else if (mantissa >= 4503599627370496) {
+      mantissa = 0;
+      biased += 1;
+    }
+    high = biased * 0x100000 + Math.floor(mantissa / 0x100000000);
+    low = mantissa % 0x100000000;
+  }
+  if (negative) high += 0x80000000;
+  return signedDecimal(high >>> 0, low >>> 0);
 }
 
 export function booleanLiteral(value: boolean): string {
-  return i64(value ? XT_TRUE : XT_FALSE);
+  return value ? XT_TRUE : XT_FALSE;
+}
+
+/** Two's-complement (high, low) 32-bit halves as a signed decimal string. */
+function signedDecimal(high: number, low: number): string {
+  if (high >= 0x80000000) {
+    let h = (~high) >>> 0;
+    let l = (~low) >>> 0;
+    l = (l + 1) >>> 0;
+    if (l === 0) h = (h + 1) >>> 0;
+    return "-" + unsignedDecimal(h, l);
+  }
+  return unsignedDecimal(high, low);
+}
+
+/** Unsigned 64-bit `high * 2^32 + low` as a decimal string. */
+function unsignedDecimal(high: number, low: number): string {
+  const digits: number[] = [];
+  let h = high;
+  if (h === 0) digits.push(0);
+  while (h > 0) {
+    digits.push(h % 10);
+    h = Math.floor(h / 10);
+  }
+  let carry = low;
+  for (let i = 0; i < digits.length; i++) {
+    const current = digits[i]! * 4294967296 + carry;
+    digits[i] = current % 10;
+    carry = Math.floor(current / 10);
+  }
+  while (carry > 0) {
+    digits.push(carry % 10);
+    carry = Math.floor(carry / 10);
+  }
+  let out = "";
+  for (let i = digits.length - 1; i >= 0; i--) out += digits[i]!;
+  return out;
 }

package/src/diagnostics/source.ts

@@ -80,15 +80,20 @@ export class SourceFile {
  * and stable across platforms which is exactly what the incremental cache
  * needs. Collision resistance is not a security property here.
  */
-export function hashText(text: string, seed = 0xcbf29ce484222325n): string {
-  let hash = seed;
-  const prime = 0x100000001b3n;
-  const mask = 0xffffffffffffffffn;
+export function hashText(text: string, seed = 0): string {
+  // Two independent 32-bit FNV-1a lanes give a wide, stable fingerprint
+  // without relying on BigInt, which the compiler cannot assume at runtime.
+  let a = (0xcbf29ce4 ^ seed) >>> 0;
+  let b = (0x84222325 ^ seed) >>> 0;
+  const prime = 0x01000193;
   for (let i = 0; i < text.length; i++) {
-    hash ^= BigInt(text.charCodeAt(i));
-    hash = (hash * prime) & mask;
+    const code = text.charCodeAt(i);
+    a = Math.imul(a ^ (code & 0xff), prime) >>> 0;
+    a = Math.imul(a ^ (code >>> 8), prime) >>> 0;
+    b = Math.imul(b ^ (code >>> 8), prime) >>> 0;
+    b = Math.imul(b ^ (code & 0xff), prime) >>> 0;
   }
-  return hash.toString(16).padStart(16, "0");
+  return (a >>> 0).toString(16).padStart(8, "0") + (b >>> 0).toString(16).padStart(8, "0");
 }
 
 /** Combine several hashes/strings into one stable fingerprint. */

package/src/driver/compiler.ts

@@ -7,7 +7,7 @@
  * nothing relevant changed.
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { basename, dirname, extname, join, resolve } from "node:path";
 import { DiagnosticBag, type Diagnostic } from "../diagnostics/diagnostic.js";
 import { SourceFile } from "../diagnostics/source.js";
@@ -246,9 +246,22 @@ function ensureRuntimeObjects(
   cacheDir: string,
   registry: ExtensionRegistry,
 ): RuntimeObjects {
+  /* Runtime objects depend on the shared headers (rt.h/rt_internal.h/...),
+     so a header change must invalidate every cached object. Hash them all. */
+  const headerParts: string[] = [];
+  const collectHeaders = (dir: string): void => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) collectHeaders(full);
+      else if (entry.name.endsWith(".h")) headerParts.push(readFileSync(full, "utf8"));
+    }
+  };
+  collectHeaders(runtimeDir);
+  const headerStamp = hashParts(headerParts);
+
   const compileOne = (sourcePath: string, tag: string): string => {
     const body = readFileSync(sourcePath, "utf8");
-    const key = hashParts(["runtime", COMPILER_VERSION, tag, body, clang, process.platform]);
+    const key = hashParts(["runtime", COMPILER_VERSION, tag, headerStamp, body, clang, process.platform]);
     const objectPath = join(cacheDir, `${tag}-${key}.o`);
     if (!existsSync(objectPath)) {
       compileC(runner, clang, sourcePath, objectPath, runtimeDir);

package/src/extensions/node/child_process/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Node's `child_process` module: `spawnSync(command, args, options)`, backed by
+ * `runtime/ext_node/child_process`. Captures stdout/stderr as UTF-8 strings and
+ * honours `options.cwd`, which is all the compiler's toolchain wrapper needs.
+ */
+
+import type { NodeModule } from "../module.js";
+import { resolveFrom } from "../module.js";
+import type { BuiltinFunction, ModuleExports } from "../../registry.js";
+
+const builtins: Record<string, BuiltinFunction> = {
+  spawnSync: { symbol: "xt_child_process_spawn_sync" },
+};
+
+const exports: ModuleExports = {
+  spawnSync: { symbol: "xt_child_process_spawn_sync" },
+};
+
+export const childProcessModule: NodeModule = {
+  name: "child_process",
+  runtimeSources: () => [resolveFrom(import.meta.url, "../../../../runtime/ext_node/child_process/child_process.c")],
+  builtins: () => builtins,
+  exports: () => exports,
+};

package/src/extensions/node/crypto/index.ts

@@ -0,0 +1,23 @@
+/**
+ * Node's `crypto` module: `createHash(...).update(...).digest("hex")`, backed
+ * by a self-contained SHA-256 in `runtime/ext_node/crypto`.
+ */
+
+import type { NodeModule } from "../module.js";
+import { resolveFrom } from "../module.js";
+import type { BuiltinFunction, ModuleExports } from "../../registry.js";
+
+const builtins: Record<string, BuiltinFunction> = {
+  createHash: { symbol: "xt_crypto_create_hash" },
+};
+
+const exports: ModuleExports = {
+  createHash: { symbol: "xt_crypto_create_hash" },
+};
+
+export const cryptoModule: NodeModule = {
+  name: "crypto",
+  runtimeSources: () => [resolveFrom(import.meta.url, "../../../../runtime/ext_node/crypto/crypto.c")],
+  builtins: () => builtins,
+  exports: () => exports,
+};

package/src/extensions/node/index.ts

@@ -22,6 +22,9 @@ import { streamModule } from "./stream/index.js";
 import { netModule } from "./net/index.js";
 import { dgramModule } from "./dgram/index.js";
 import { httpModule } from "./http/index.js";
+import { urlModule } from "./url/index.js";
+import { cryptoModule } from "./crypto/index.js";
+import { childProcessModule } from "./child_process/index.js";
 
 /** Every Node module the extension currently provides. */
 const modules: readonly NodeModule[] = [
@@ -35,6 +38,9 @@ const modules: readonly NodeModule[] = [
   netModule,
   dgramModule,
   httpModule,
+  urlModule,
+  cryptoModule,
+  childProcessModule,
 ];
 
 export const nodeExtension: Extension = {

package/src/extensions/node/module.ts

@@ -7,6 +7,7 @@
 
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { findRuntimeDir } from "../../driver/paths.js";
 import type { BuiltinFunction, ModuleExports } from "../registry.js";
 
 export interface NodeModule {
@@ -26,7 +27,18 @@ export interface NodeModule {
   exports?(): ModuleExports;
 }
 
-/** Resolve a path relative to the folder of the module that calls this. */
+/**
+ * Resolve a C runtime source that is written relative to an extension module
+ * (e.g. `../../../../runtime/ext_node/fs/read_file.c`).
+ *
+ * When running from source the page is resolved against the calling module's
+ * own URL, but inside a compiled xbintsc binary `import.meta.url` points at the
+ * executable, so the module-relative form no longer resolves. Anchor on the
+ * discovered runtime directory instead, which is correct in both worlds.
+ */
 export function resolveFrom(importMetaUrl: string, relative: string): string {
+  const marker = "runtime/";
+  const index = relative.indexOf(marker);
+  if (index >= 0) return resolve(findRuntimeDir(), relative.slice(index + marker.length));
   return resolve(dirname(fileURLToPath(importMetaUrl)), relative);
 }

package/src/extensions/node/url/index.ts

@@ -0,0 +1,26 @@
+/**
+ * Node's `url` module: `pathToFileURL` / `fileURLToPath`, backed by
+ * `runtime/ext_node/url`. These are the helpers the compiler uses to relate
+ * `import.meta.url`, `process.argv[1]` and filesystem paths.
+ */
+
+import type { NodeModule } from "../module.js";
+import { resolveFrom } from "../module.js";
+import type { BuiltinFunction, ModuleExports } from "../../registry.js";
+
+const builtins: Record<string, BuiltinFunction> = {
+  pathToFileURL: { symbol: "xt_url_path_to_file_url" },
+  fileURLToPath: { symbol: "xt_url_file_url_to_path" },
+};
+
+const exports: ModuleExports = {
+  pathToFileURL: { symbol: "xt_url_path_to_file_url" },
+  fileURLToPath: { symbol: "xt_url_file_url_to_path" },
+};
+
+export const urlModule: NodeModule = {
+  name: "url",
+  runtimeSources: () => [resolveFrom(import.meta.url, "../../../../runtime/ext_node/url/url.c")],
+  builtins: () => builtins,
+  exports: () => exports,
+};

package/src/lexer/scanner.ts

@@ -240,12 +240,12 @@ export class Scanner {
     const cleaned = raw.replace(/_/g, "");
     if (isBigInt) {
       raw = raw.slice(0, -1).replace(/_/g, "");
-      try {
-        return this.makeToken(TokenKind.BigIntLiteral, start, this.pos, raw, precededByLineBreak, BigInt(raw));
-      } catch {
+      const parsed = Number(raw);
+      if (parsed !== parsed) {
         this.error(DiagnosticCode.InvalidNumber, `Invalid BigInt literal '${raw}'`, start, this.pos);
-        return this.makeToken(TokenKind.BigIntLiteral, start, this.pos, raw, precededByLineBreak, 0n);
+        return this.makeToken(TokenKind.BigIntLiteral, start, this.pos, raw, precededByLineBreak, 0);
       }
+      return this.makeToken(TokenKind.BigIntLiteral, start, this.pos, raw, precededByLineBreak, parsed);
     }
     let value: number;
     if (/^0[xX]/.test(cleaned)) value = parseInt(cleaned.slice(2), 16);

package/src/parser/declarations.ts

@@ -157,9 +157,11 @@ export const declarationMethods: DeclarationMethods = {
         dotDotDotToken = true;
       }
       let name: import("../ast/declarations.js").BindingName;
+      let isThisParameter = false;
       if (this.at(TokenKind.ThisKeyword)) {
         const thisToken = this.nextToken();
         name = { kind: SyntaxKind.Identifier, text: "this", start: thisToken.start, end: thisToken.end };
+        isThisParameter = true;
       } else {
         name = this.parseBindingName();
       }
@@ -178,7 +180,11 @@ export const declarationMethods: DeclarationMethods = {
         this.nextToken();
         initializer = this.parseAssignmentExpression();
       }
-      params.push({ kind: SyntaxKind.Parameter, name, modifiers, dotDotDotToken, questionToken, type, initializer, start, end: initializer?.end ?? type?.end ?? name.end });
+      // A `this` parameter is a type-level annotation only and is never a
+      // runtime argument, so it must not occupy an `argv` slot.
+      if (!isThisParameter) {
+        params.push({ kind: SyntaxKind.Parameter, name, modifiers, dotDotDotToken, questionToken, type, initializer, start, end: initializer?.end ?? type?.end ?? name.end });
+      }
       if (this.at(TokenKind.Comma)) this.nextToken();
       else break;
     }
@@ -452,13 +458,10 @@ export const declarationMethods: DeclarationMethods = {
       return { kind: SyntaxKind.NumericLiteral, text: token.text, value: Number(token.value ?? 0), start: token.start, end: token.end };
     }
     if (token.kind === TokenKind.OpenBracket) {
-      this.nextToken();
+      const start = this.nextToken().start;
       const expr = this.parseAssignmentExpression();
-      this.parseExpected(TokenKind.CloseBracket);
-      const name = expressionToPropertyName(expr);
-      if (name) return name;
-      this.error(DiagnosticCode.InvalidTypeSyntax, "Computed property names are not supported by xbintsc");
-      return { kind: SyntaxKind.Identifier, text: "<computed>", start: expr.start, end: expr.end };
+      const close = this.parseExpected(TokenKind.CloseBracket);
+      return { kind: SyntaxKind.ComputedPropertyName, expression: expr, start, end: close.end };
     }
     return this.parseIdentifierName();
   },

package/src/parser/expressions.ts

@@ -331,7 +331,7 @@ export const expressionMethods: ExpressionMethods = {
       }
       case TokenKind.BigIntLiteral:
         this.nextToken();
-        return { kind: SyntaxKind.BigIntLiteral, text: token.text, value: BigInt(token.value ?? 0n), start: token.start, end: token.end };
+        return { kind: SyntaxKind.BigIntLiteral, text: token.text, value: Number(token.value ?? 0), start: token.start, end: token.end };
       case TokenKind.StringLiteral:
         this.nextToken();
         return this.stringLiteralFromToken(token);