xbintsc 0.2.4 → 0.2.5

package/src/ast/declarations.ts

@@ -14,7 +14,7 @@ import type { TypeElement } from "./types.js";
 
 export interface Parameter extends Node {
   readonly kind: SyntaxKind.Parameter;
-  readonly name: Identifier;
+  readonly name: BindingName;
   readonly modifiers: Modifier[];
   readonly dotDotDotToken: boolean;
   readonly questionToken: boolean;
@@ -22,6 +22,29 @@ export interface Parameter extends Node {
   readonly initializer?: Expression;
 }
 
+// -- binding patterns (destructuring) --------------------------------------
+
+export type BindingName = Identifier | ArrayBindingPattern | ObjectBindingPattern;
+
+export interface BindingElement extends Node {
+  readonly kind: SyntaxKind.BindingElement;
+  readonly name: BindingName;
+  /** For `{ a: b }` the `a`; absent for shorthand and array patterns. */
+  readonly propertyName?: PropertyName;
+  readonly dotDotDotToken: boolean;
+  readonly initializer?: Expression;
+}
+
+export interface ArrayBindingPattern extends Node {
+  readonly kind: SyntaxKind.ArrayBindingPattern;
+  readonly elements: (BindingElement | undefined)[];
+}
+
+export interface ObjectBindingPattern extends Node {
+  readonly kind: SyntaxKind.ObjectBindingPattern;
+  readonly elements: BindingElement[];
+}
+
 export interface TypeParameterDeclaration extends Node {
   readonly kind: SyntaxKind.TypeParameterDeclaration;
   readonly name: Identifier;
@@ -74,6 +97,8 @@ export interface MethodDeclaration extends Node {
   readonly body?: Block;
   readonly flags: NodeFlags;
   readonly optional: boolean;
+  /** Present for `get x()` / `set x(v)` accessors. */
+  readonly accessor?: "get" | "set";
 }
 
 export interface ConstructorDeclaration extends Node {

package/src/ast/kinds.ts

@@ -59,6 +59,9 @@ export const enum SyntaxKind {
   AwaitExpression = 43,
   YieldExpression = 44,
   TaggedTemplateExpression = 45,
+  ArrayBindingPattern = 46,
+  ObjectBindingPattern = 47,
+  BindingElement = 48,
 
   // Statements
   ExpressionStatement = 60,
@@ -173,4 +176,5 @@ export const enum ModifierKind {
   Static = "static",
   Readonly = "readonly",
   Async = "async",
+  Const = "const",
 }

package/src/ast/statements.ts

@@ -5,6 +5,7 @@
 import { SyntaxKind } from "./kinds.js";
 import type { Expression, Modifier, Node, Statement, TypeNode } from "./common.js";
 import type { Identifier } from "./expressions.js";
+import type { BindingName } from "./declarations.js";
 
 // ---------------------------------------------------------------------------
 // Statements
@@ -30,7 +31,7 @@ export interface DebuggerStatement extends Node {
 
 export interface VariableDeclaration extends Node {
   readonly kind: SyntaxKind.VariableDeclaration;
-  readonly name: Identifier;
+  readonly name: BindingName;
   readonly exclamation: boolean;
   readonly type?: TypeNode;
   readonly initializer?: Expression;

package/src/binder/binder.ts

@@ -13,6 +13,7 @@ import { NodeFlags, ModifierKind } from "../ast/kinds.js";
 import {
   SyntaxKind,
   type ArrowFunction,
+  type BindingName,
   type Block,
   type ClassDeclaration,
   type ClassExpression,
@@ -244,6 +245,27 @@ class Binder {
     return { kind, node, parent, fn: this.current, symbols: new Map() };
   }
 
+  /** Declare every identifier introduced by a (possibly destructured) binding. */
+  private declareBinding(
+    name: BindingName,
+    kind: SymbolKind,
+    declaration: Node,
+    scope: Scope,
+    mutable: boolean,
+  ): SymbolInfo | undefined {
+    if (name.kind === SyntaxKind.Identifier) {
+      return this.declare(name.text, kind, declaration, scope, mutable);
+    }
+    let first: SymbolInfo | undefined;
+    const pattern = name as import("../ast/declarations.js").ArrayBindingPattern | import("../ast/declarations.js").ObjectBindingPattern;
+    for (const element of pattern.elements) {
+      if (!element) continue;
+      const symbol = this.declareBinding(element.name, kind, element.name, scope, mutable);
+      if (!first) first = symbol;
+    }
+    return first;
+  }
+
   private declare(
     name: string,
     kind: SymbolKind,
@@ -334,7 +356,7 @@ class Binder {
           ? SymbolKind.Var
           : SymbolKind.Let;
     for (const declaration of list.declarations) {
-      this.declare(declaration.name.text, kind, declaration, scope, kind !== SymbolKind.Const);
+      this.declareBinding(declaration.name, kind, declaration, scope, kind !== SymbolKind.Const);
     }
   }
 
@@ -369,9 +391,9 @@ class Binder {
           const decl = node as VariableStatement;
           if (decl.declarationList.declarationKind === "var") {
             for (const d of decl.declarationList.declarations) {
-              const existing = fn.scope.symbols.get(d.name.text);
-              if (!existing) this.declare(d.name.text, SymbolKind.Var, d, fn.scope, true);
-              else this.symbolOfDeclaration.set(d, existing);
+              const existing = d.name.kind === SyntaxKind.Identifier ? fn.scope.symbols.get(d.name.text) : undefined;
+              if (!existing) this.declareBinding(d.name, SymbolKind.Var, d, fn.scope, true);
+              else if (d.name.kind === SyntaxKind.Identifier) this.symbolOfDeclaration.set(d, existing);
             }
           }
           return;
@@ -506,11 +528,26 @@ class Binder {
   private bindVariableList(list: VariableDeclarationList, scope: Scope): void {
     for (const declaration of list.declarations) {
       const symbol = this.symbolOfDeclaration.get(declaration);
-      if (declaration.name) this.symbolOfDeclaration.set(declaration.name, symbol ?? this.symbolOfDeclaration.get(declaration) as SymbolInfo);
+      if (declaration.name.kind === SyntaxKind.Identifier) {
+        this.symbolOfDeclaration.set(declaration.name, symbol ?? this.symbolOfDeclaration.get(declaration) as SymbolInfo);
+      } else {
+        this.bindBindingPattern(declaration.name, scope);
+      }
       this.bindNode(declaration.initializer, scope);
     }
   }
 
+  /** Bind default-value expressions inside a binding pattern. */
+  private bindBindingPattern(name: BindingName, scope: Scope): void {
+    if (name.kind === SyntaxKind.Identifier) return;
+    const pattern = name as import("../ast/declarations.js").ArrayBindingPattern | import("../ast/declarations.js").ObjectBindingPattern;
+    for (const element of pattern.elements) {
+      if (!element) continue;
+      if (element.initializer) this.bindNode(element.initializer, scope);
+      this.bindBindingPattern(element.name, scope);
+    }
+  }
+
   private bindFunction(
     node: FunctionDeclaration | FunctionExpression | ArrowFunction,
     parentScope: Scope,
@@ -533,8 +570,8 @@ class Binder {
     // Parameters live in the function scope.
     const params: SymbolInfo[] = [];
     for (const parameter of node.parameters) {
-      const paramSymbol = this.declare(parameter.name.text, SymbolKind.Parameter, parameter, scope, true);
-      params.push(paramSymbol);
+      const paramSymbol = this.declareBinding(parameter.name, SymbolKind.Parameter, parameter, scope, true);
+      if (paramSymbol) params.push(paramSymbol);
       if (parameter.initializer) this.bindNode(parameter.initializer, scope);
     }
     (fn as { params: SymbolInfo[] }).params = params;
@@ -651,8 +688,8 @@ class Binder {
 
     const params: SymbolInfo[] = [];
     for (const parameter of parameters) {
-      const paramSymbol = this.declare(parameter.name.text, SymbolKind.Parameter, parameter, scope, true);
-      params.push(paramSymbol);
+      const paramSymbol = this.declareBinding(parameter.name, SymbolKind.Parameter, parameter, scope, true);
+      if (paramSymbol) params.push(paramSymbol);
       if (parameter.initializer) this.bindNode(parameter.initializer, scope);
     }
     (fn as { params: SymbolInfo[] }).params = params;

package/src/cli/main.ts

@@ -16,7 +16,7 @@ import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { DiagnosticBag, formatDiagnostic, type Diagnostic } from "../diagnostics/diagnostic.js";
 import { SourceFile } from "../diagnostics/source.js";
-import { build, compileString, COMPILER_VERSION, type EmitKind } from "../driver/compiler.js";
+import { build, compileEntry, COMPILER_VERSION, type EmitKind } from "../driver/compiler.js";
 import { createDefaultRegistry, type ExtensionRegistry } from "../extensions/registry.js";
 import { nodeExtension } from "../extensions/node/index.js";
 
@@ -152,9 +152,8 @@ export function run(argv: readonly string[], io: CliIo = defaultIo): number {
       io.stderr("xbintsc: emit requires a source file\n");
       return 1;
     }
-    const source = readFileSync(resolve(entry), "utf8");
     const registry = buildRegistry(args.flags);
-    const { ir, diagnostics } = compileString(source, entry, registry);
+    const { ir, diagnostics } = compileEntry(entry, registry);
     if (diagnostics.some((d) => d.category === "error")) {
       printDiagnostics(diagnostics, entry, io);
       return 1;

package/src/codegen/generator/expressions.ts

@@ -69,6 +69,22 @@ export const expressionMethods: ExpressionMethods = {
         return this.stringValue((node as { value: string }).value);
       case SyntaxKind.NoSubstitutionTemplateLiteral:
         return this.stringValue((node as { value: string }).value);
+      case SyntaxKind.RegularExpressionLiteral: {
+        const regex = node as { pattern: string; flags: string };
+        const pattern = this.stringValue(regex.pattern);
+        const flags = this.stringValue(regex.flags);
+        const ptr = `%regex${this.current.allocas.length}`;
+        this.current.allocas.push(`${ptr} = alloca i64, i32 2`);
+        const slot0 = this.reg();
+        this.emit(`  ${slot0} = getelementptr i64, i64* ${ptr}, i32 0`);
+        this.emit(`  store i64 ${pattern}, i64* ${slot0}`);
+        const slot1 = this.reg();
+        this.emit(`  ${slot1} = getelementptr i64, i64* ${ptr}, i32 1`);
+        this.emit(`  store i64 ${flags}, i64* ${slot1}`);
+        const result = this.reg();
+        this.emit(`  ${result} = call i64 @xt_regexp_ctor(i32 2, i64* ${ptr})`);
+        return result;
+      }
       case SyntaxKind.TemplateLiteral:
         return this.emitTemplate(node as TemplateLiteral);
       case SyntaxKind.TrueKeyword:
@@ -87,6 +103,15 @@ export const expressionMethods: ExpressionMethods = {
         return this.emitExpression((node as { expression: Expression }).expression);
       case SyntaxKind.DeleteExpression:
         return this.emitDelete(node as DeleteExpression);
+      case SyntaxKind.TypeOfExpression: {
+        const operand = this.emitExpression((node as { expression: Expression }).expression);
+        const result = this.reg();
+        this.emit(`  ${result} = call i64 @xt_typeof(i64 ${operand})`);
+        return result;
+      }
+      case SyntaxKind.VoidExpression:
+        this.emitExpression((node as { expression: Expression }).expression);
+        return i64(XT_UNDEFINED);
       case SyntaxKind.ThisKeyword:
         return this.emitThis();
       case SyntaxKind.NewExpression:

package/src/codegen/generator/module.ts

@@ -8,6 +8,7 @@ import {
   type ArrowFunction,
   type Block,
   type Expression,
+  type Identifier,
   type Parameter,
 } from "../../ast/nodes.js";
 import type { ClassInfo, FunctionInfo, SymbolInfo } from "../../binder/binder.js";
@@ -40,8 +41,11 @@ export const moduleMethods: ModuleMethods = {
     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 isVariable =
+          symbol.kind === SymbolKind.Var || symbol.kind === SymbolKind.Let || symbol.kind === SymbolKind.Const;
+        const isEnum = symbol.kind === SymbolKind.Enum;
+        if ((!isVariable && !isEnum) || !symbol.fn?.isModule) continue;
+        if (isVariable && !symbol.boxed) continue;
         const globalName = `@g.${symbol.id}`;
         this.moduleGlobals.set(symbol.id, globalName);
         this.globals.push(`${globalName} = internal global i64 ${i64(XT_UNDEFINED)}`);
@@ -199,10 +203,19 @@ export const moduleMethods: ModuleMethods = {
     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})`);
+      // `extends Error` (and other host builtins) have no runtime class value;
+      // the subclass still works, it simply does not inherit a prototype.
+      const parent = classInfo.parentExpression;
+      const unboundBuiltin =
+        parent.kind === SyntaxKind.Identifier &&
+        (parent as Identifier).text === "Error" &&
+        !this.binding.symbolOfIdentifier.get(parent as Identifier);
+      if (!unboundBuiltin) {
+        const parentValue = this.emitExpression(parent);
+        const parentProto = this.reg();
+        this.emit(`  ${parentProto} = call i64 @xt_function_get_prototype(i64 ${parentValue})`);
+        this.emit(`  call i64 @xt_object_set_prototype(i64 ${proto}, i64 ${parentProto})`);
+      }
     }
     for (const method of classInfo.methods) {
       const fnValue = this.emitClosureValue(method);

package/src/codegen/generator/state.ts

@@ -101,6 +101,7 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_set_ctor(i32, i64*)",
   "declare i64 @xt_date_ctor(i32, i64*)",
   "declare i64 @xt_regexp_ctor(i32, i64*)",
+  "declare i64 @xt_error_ctor(i32, i64*)",
   "declare i64 @xt_json_parse(i32, i64*)",
   "declare i64 @xt_json_stringify(i32, i64*)",
   "declare i64 @xt_object_from_entries(i64)",

package/src/codegen/generator/statements.ts

@@ -4,15 +4,19 @@
 
 import {
   SyntaxKind,
+  type ArrayBindingPattern,
+  type BindingName,
   type Block,
   type CaseClause,
   type DoStatement,
+  type EnumDeclaration,
   type Expression,
   type ForInStatement,
   type ForOfStatement,
   type ForStatement,
   type Identifier,
   type IfStatement,
+  type ObjectBindingPattern,
   type ReturnStatement,
   type Statement,
   type SwitchStatement,
@@ -23,12 +27,16 @@ import {
   type WhileStatement,
 } from "../../ast/nodes.js";
 import { i64, numberLiteral, XT_UNDEFINED } from "../values.js";
+import { propertyNameText } from "./tables.js";
 import type { Generator } from "./generator.js";
 
 export interface StatementMethods {
   emitStatements(this: Generator, statements: readonly Statement[]): void;
   emitStatement(this: Generator, statement: Statement): void;
   emitVariableStatement(this: Generator, statement: VariableStatement): void;
+  emitBindingPattern(this: Generator, name: BindingName, value: string): void;
+  emitBindingDefault(this: Generator, value: string, initializer: Expression): string;
+  emitEnum(this: Generator, statement: EnumDeclaration): void;
   emitIf(this: Generator, statement: IfStatement): void;
   emitWhile(this: Generator, statement: WhileStatement): void;
   emitDo(this: Generator, statement: DoStatement): void;
@@ -125,6 +133,9 @@ export const statementMethods: StatementMethods = {
         if (declaration) this.emitStatement(declaration);
         return;
       }
+      case SyntaxKind.EnumDeclaration:
+        this.emitEnum(statement as EnumDeclaration);
+        return;
       default:
         this.unsupported(statement, "statement");
     }
@@ -132,16 +143,114 @@ export const statementMethods: StatementMethods = {
 
   emitVariableStatement(statement: VariableStatement): void {
     for (const declaration of statement.declarationList.declarations) {
-      const symbol = this.binding.symbolOfDeclaration.get(declaration);
-      if (!symbol) continue;
-      if (this.current.slots.has(symbol.id)) continue; // hoisted `var`
       const initial = declaration.initializer
         ? this.emitExpression(declaration.initializer)
         : i64(XT_UNDEFINED);
-      this.declareSlot(symbol, initial);
+      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`
+        this.declareSlot(symbol, initial);
+      } else {
+        this.emitBindingPattern(declaration.name, initial);
+      }
+    }
+  },
+
+  /** Lower a destructuring binding pattern, declaring each bound identifier. */
+  emitBindingPattern(name: BindingName, value: string): void {
+    if (name.kind === SyntaxKind.Identifier) {
+      const symbol = this.binding.symbolOfDeclaration.get(name);
+      if (!symbol) return;
+      if (this.current.slots.has(symbol.id)) this.writeSlot(symbol, value);
+      else this.declareSlot(symbol, value);
+      return;
+    }
+    if (name.kind === SyntaxKind.ArrayBindingPattern) {
+      const pattern = name as ArrayBindingPattern;
+      for (let index = 0; index < pattern.elements.length; index++) {
+        const element = pattern.elements[index];
+        if (!element) continue;
+        let elementValue: string;
+        if (element.dotDotDotToken) {
+          const startPtr = this.alloca();
+          this.emit(`  store i64 ${numberLiteral(index)}, i64* ${startPtr}`);
+          const sliceName = this.stringValue("slice");
+          elementValue = this.reg();
+          this.emit(`  ${elementValue} = call i64 @xt_call_method(i64 ${value}, i64 ${sliceName}, i32 1, i64* ${startPtr})`);
+        } else {
+          elementValue = this.reg();
+          this.emit(`  ${elementValue} = call i64 @xt_get(i64 ${value}, i64 ${numberLiteral(index)})`);
+        }
+        if (element.initializer) elementValue = this.emitBindingDefault(elementValue, element.initializer);
+        this.emitBindingPattern(element.name, elementValue);
+      }
+      return;
+    }
+    const pattern = name as ObjectBindingPattern;
+    for (const element of pattern.elements) {
+      const key = element.propertyName ?? (element.name.kind === SyntaxKind.Identifier ? element.name : undefined);
+      if (element.dotDotDotToken) {
+        this.unsupported(element, "object rest destructuring");
+        continue;
+      }
+      const keyValue = this.stringValue(key ? propertyNameText(key) : "undefined");
+      let elementValue = this.reg();
+      this.emit(`  ${elementValue} = call i64 @xt_get(i64 ${value}, i64 ${keyValue})`);
+      if (element.initializer) elementValue = this.emitBindingDefault(elementValue, element.initializer);
+      this.emitBindingPattern(element.name, elementValue);
     }
   },
 
+  /** `x = fallback` in a binding pattern: only apply when `x` is `undefined`. */
+  emitBindingDefault(value: string, initializer: Expression): string {
+    const fallback = this.emitExpression(initializer);
+    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 result = this.reg();
+    this.emit(`  ${result} = select i1 ${condition}, i64 ${fallback}, i64 ${value}`);
+    return result;
+  },
+
+  /**
+   * `enum E { A, B }` (and `const enum`) lowers to a runtime object with both
+   * forward (`E.A`) and reverse (`E[0] === "A"`) numeric mappings.
+   */
+  emitEnum(statement: EnumDeclaration): void {
+    const symbol = this.binding.symbolOfDeclaration.get(statement);
+    const object = this.reg();
+    this.emit(`  ${object} = call i64 @xt_object_new()`);
+    let next = 0;
+    for (const member of statement.members) {
+      const name = propertyNameText(member.name);
+      const key = this.stringValue(name);
+      let value: string;
+      if (member.initializer) {
+        value = this.emitExpression(member.initializer);
+        if (member.initializer.kind === SyntaxKind.NumericLiteral) {
+          const numeric = (member.initializer as { value?: number }).value ?? 0;
+          next = numeric + 1;
+        } else {
+          next++; 
+        }
+      } else {
+        value = numberLiteral(next);
+        next++;
+      }
+      this.emit(`  call i64 @xt_set(i64 ${object}, i64 ${key}, i64 ${value})`);
+      // Reverse mapping (only meaningful for numeric members).
+      if (!member.initializer || member.initializer.kind === SyntaxKind.NumericLiteral) {
+        const reverseKey = this.stringValue(name);
+        this.emit(`  call i64 @xt_set(i64 ${object}, i64 ${value}, i64 ${reverseKey})`);
+      }
+    }
+    if (symbol) this.declareSlot(symbol, object);
+  },
+
   emitIf(statement: IfStatement): void {
     const thenLabel = this.label("if.then");
     const elseLabel = statement.elseStatement ? this.label("if.else") : undefined;
@@ -300,7 +409,11 @@ export const statementMethods: StatementMethods = {
     if (initializer.kind === SyntaxKind.VariableDeclarationList) {
       const declaration = initializer.declarations[0];
       if (!declaration) return;
-      const symbol = this.binding.symbolOfDeclaration.get(declaration);
+      if (declaration.name.kind !== SyntaxKind.Identifier) {
+        this.emitBindingPattern(declaration.name, value);
+        return;
+      }
+      const symbol = this.binding.symbolOfDeclaration.get(declaration) ?? this.binding.symbolOfDeclaration.get(declaration.name);
       if (symbol) {
         if (this.current.slots.has(symbol.id)) this.writeSlot(symbol, value);
         else this.declareSlot(symbol, value);

package/src/codegen/generator/tables.ts

@@ -116,6 +116,7 @@ export const CTOR_FUNCTIONS: Record<string, string> = {
   Set: "xt_set_ctor",
   Date: "xt_date_ctor",
   RegExp: "xt_regexp_ctor",
+  Error: "xt_error_ctor",
   Promise: "xt_promise_ctor",
   Buffer: "xt_buffer_ctor",
   Readable: "xt_readable_ctor",

package/src/driver/compiler.ts

@@ -73,6 +73,35 @@ export function compileString(source: string, fileName = "input.ts", extensions?
   return { ir, diagnostics: diagnostics.diagnostics };
 }
 
+/**
+ * Compile a file to LLVM IR, bundling every reachable relative module first so
+ * that imports from other TypeScript sources resolve exactly like `build`.
+ */
+export function compileEntry(entryPath: string, extensions?: ExtensionRegistry): CompileStringResult {
+  const absoluteEntry = resolve(entryPath);
+  const sourceText = readFileSync(absoluteEntry, "utf8");
+  const file = new SourceFile(absoluteEntry, sourceText);
+  const diagnostics = new DiagnosticBag();
+  const parser = new Parser(file, diagnostics);
+  let sourceFile = parser.parseSourceFile();
+  const isModule = sourceFile.statements.some(
+    (statement) =>
+      statement.kind === SyntaxKind.ImportDeclaration ||
+      statement.kind === SyntaxKind.ExportDeclaration ||
+      statement.kind === SyntaxKind.ExportAssignment,
+  );
+  if (isModule) {
+    const bundled = bundleModules(absoluteEntry, diagnostics);
+    if (bundled) sourceFile = bundled.sourceFile;
+  }
+  const registry = extensions ?? createDefaultRegistry();
+  const { ir } = generate(sourceFile, diagnostics, {
+    builtins: registry.builtins(),
+    modules: registry.modules(),
+  });
+  return { ir, diagnostics: diagnostics.diagnostics };
+}
+
 function executableName(entry: string, outDir: string, explicit: string | undefined): string {
   if (explicit) return resolve(explicit);
   const base = basename(entry, extname(entry));

package/src/driver/modules.ts

@@ -65,6 +65,18 @@ function isExternalSpecifier(specifier: string): boolean {
 
 function resolveModule(fromDir: string, specifier: string): string | undefined {
   const base = resolve(fromDir, specifier);
+  // TypeScript sources are imported using their emitted `.js` extension
+  // (`import ... from "./foo.js"`), so map the extension back to the source
+  // file before probing the usual suffixes.
+  const candidates = [base];
+  const jsExtension = /\.(?:m|c)?jsx?$/.exec(base);
+  if (jsExtension) {
+    const stem = base.slice(0, jsExtension.index);
+    candidates.push(`${stem}.ts`, `${stem}.tsx`, `${stem}.mts`, `${stem}.cts`);
+  }
+  for (const candidate of candidates) {
+    if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
+  }
   for (const suffix of RESOLVE_SUFFIXES) {
     const candidate = base + suffix;
     if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
@@ -86,8 +98,10 @@ function declarationName(node: Node): Identifier | undefined {
     case SyntaxKind.TypeAliasDeclaration:
     case SyntaxKind.ModuleDeclaration:
       return (node as { name?: Identifier }).name;
-    case SyntaxKind.VariableDeclaration:
-      return (node as VariableDeclaration).name;
+    case SyntaxKind.VariableDeclaration: {
+      const name = (node as VariableDeclaration).name;
+      return name.kind === SyntaxKind.Identifier ? name : undefined;
+    }
     default:
       return undefined;
   }
@@ -349,7 +363,7 @@ function exportedNames(statement: Statement): string[] {
   const names: string[] = [];
   if (statement.kind === SyntaxKind.VariableStatement) {
     for (const declaration of (statement as VariableStatement).declarationList.declarations) {
-      if (declaration.name) names.push(declaration.name.text);
+      collectBindingIdentifiers(declaration.name, names);
     }
   } else {
     const name = declarationName(statement);
@@ -358,6 +372,17 @@ function exportedNames(statement: Statement): string[] {
   return names;
 }
 
+function collectBindingIdentifiers(name: import("../ast/declarations.js").BindingName, out: string[]): void {
+  if (name.kind === SyntaxKind.Identifier) {
+    out.push(name.text);
+    return;
+  }
+  const elements = name.kind === SyntaxKind.ArrayBindingPattern ? name.elements : name.elements;
+  for (const element of elements) {
+    if (element) collectBindingIdentifiers(element.name, out);
+  }
+}
+
 /** Turn `export default expr` into a synthetic `const` declaration. */
 function exportAssignmentToStatement(record: ModuleRecord, assignment: ExportAssignment): Statement {
   const name: Identifier = {

package/src/lexer/token.ts

@@ -264,3 +264,76 @@ export const CONTEXTUAL_KEYWORDS: ReadonlySet<TokenKind> = new Set([
 export function isOfKeyword(token: Token): boolean {
   return token.kind === TokenKind.Identifier && token.text === "of";
 }
+
+/** Every keyword token kind, derived from the scanner's keyword table. */
+export const KEYWORD_KINDS: ReadonlySet<TokenKind> = new Set(KEYWORDS.values());
+
+/**
+ * True for the hard/contextual keywords the scanner emits. Property names and
+ * member access allow any of these (`obj.default`, `{ type: 1 }`), so the
+ * parser consults this instead of maintaining a hand-written allow list.
+ */
+export function isKeywordKind(kind: TokenKind): boolean {
+  return KEYWORD_KINDS.has(kind);
+}
+
+/**
+ * Keywords that can never be used as a plain binding/identifier. Everything
+ * else the scanner recognizes is a TypeScript contextual keyword (`type`,
+ * `async`, `module`, `namespace`, `readonly`, …) and may legally name a
+ * variable, parameter or property.
+ */
+const RESERVED_KEYWORDS: ReadonlySet<TokenKind> = new Set([
+  TokenKind.BreakKeyword,
+  TokenKind.CaseKeyword,
+  TokenKind.CatchKeyword,
+  TokenKind.ClassKeyword,
+  TokenKind.ConstKeyword,
+  TokenKind.ContinueKeyword,
+  TokenKind.DebuggerKeyword,
+  TokenKind.DefaultKeyword,
+  TokenKind.DeleteKeyword,
+  TokenKind.DoKeyword,
+  TokenKind.ElseKeyword,
+  TokenKind.EnumKeyword,
+  TokenKind.ExportKeyword,
+  TokenKind.ExtendsKeyword,
+  TokenKind.FalseKeyword,
+  TokenKind.FinallyKeyword,
+  TokenKind.ForKeyword,
+  TokenKind.FunctionKeyword,
+  TokenKind.IfKeyword,
+  TokenKind.ImportKeyword,
+  TokenKind.InKeyword,
+  TokenKind.InstanceOfKeyword,
+  TokenKind.NewKeyword,
+  TokenKind.NullKeyword,
+  TokenKind.ReturnKeyword,
+  TokenKind.SuperKeyword,
+  TokenKind.SwitchKeyword,
+  TokenKind.ThisKeyword,
+  TokenKind.ThrowKeyword,
+  TokenKind.TrueKeyword,
+  TokenKind.TryKeyword,
+  TokenKind.TypeOfKeyword,
+  TokenKind.VarKeyword,
+  TokenKind.VoidKeyword,
+  TokenKind.WhileKeyword,
+  TokenKind.WithKeyword,
+  // Strict-mode / module reserved words.
+  TokenKind.LetKeyword,
+  TokenKind.StaticKeyword,
+  TokenKind.YieldKeyword,
+  TokenKind.AwaitKeyword,
+  TokenKind.ImplementsKeyword,
+  TokenKind.InterfaceKeyword,
+  TokenKind.PackageKeyword,
+  TokenKind.PrivateKeyword,
+  TokenKind.ProtectedKeyword,
+  TokenKind.PublicKeyword,
+]);
+
+/** True when the scanner token may be used as an identifier/binding name. */
+export function isIdentifierNameToken(kind: TokenKind): boolean {
+  return kind === TokenKind.Identifier || (isKeywordKind(kind) && !RESERVED_KEYWORDS.has(kind));
+}