xbintsc 0.5.23 → 0.5.32

package/scripts/setup-vs-toolchain.ps1

@@ -0,0 +1,152 @@
+#!/usr/bin/env pwsh
+<#
+.SYNOPSIS
+  Select the Visual Studio MSVC + LLVM toolchain for a Windows build.
+
+.DESCRIPTION
+  Finds the Visual Studio installation that owns the C++ build tools, imports
+  its `vcvarsall` environment (INCLUDE, LIB, PATH, ...), verifies the LLVM
+  bundled with that same installation (`clang`, `clang++`, `clang-cl`,
+  `llvm-ar`, `llvm-rc`) and exposes it as `xbintsc_CLANG`.
+
+  This is the toolchain a local build resolves and the one the prebuilt
+  `gui.lib` / `media.lib` archives are compiled with. GitHub Actions calls this
+  script from `.github/actions/vs-toolchain` instead of installing a separate
+  LLVM, so CI and local builds share one compiler chain.
+
+  Run it directly from a PowerShell prompt to use the same environment
+  interactively:
+
+      pwsh -File scripts/setup-vs-toolchain.ps1
+
+  In GitHub Actions it also appends the environment to `GITHUB_ENV` and the
+  LLVM bin directory to `GITHUB_PATH`, so later steps see it.
+
+.PARAMETER InstallMake
+  Install GNU make through Chocolatey (the FFmpeg media build needs it). Only
+  used by CI; a local developer already has a native GNU make on PATH.
+#>
+[CmdletBinding()]
+param(
+  [switch]$InstallMake
+)
+
+$ErrorActionPreference = "Stop"
+
+function Write-GitHubEnv([string]$name, [string]$value) {
+  if ($env:GITHUB_ENV) {
+    "$name=$value" | Out-File -FilePath $env:GITHUB_ENV -Append -Encoding utf8
+  }
+}
+
+function Write-GitHubPath([string]$path) {
+  if ($env:GITHUB_PATH) {
+    $path | Out-File -FilePath $env:GITHUB_PATH -Append -Encoding utf8
+  }
+}
+
+# 1. Find Visual Studio with the C++ tools for this machine's architecture.
+$arch = if ($env:RUNNER_ARCH -eq "ARM64" -or $env:PROCESSOR_ARCHITECTURE -eq "ARM64") { "arm64" } else { "x64" }
+$llvmArch = if ($arch -eq "arm64") { "ARM64" } else { "x64" }
+$component = if ($arch -eq "arm64") {
+  "Microsoft.VisualStudio.Component.VC.Tools.arm64"
+} else {
+  "Microsoft.VisualStudio.Component.VC.Tools.x86.x64"
+}
+
+$programFilesX86 = [Environment]::GetFolderPath("ProgramFilesX86")
+$vswhere = Join-Path $programFilesX86 "Microsoft Visual Studio\Installer\vswhere.exe"
+if (-not (Test-Path $vswhere)) {
+  $vswhere = Join-Path $env:ProgramFiles "Microsoft Visual Studio\Installer\vswhere.exe"
+}
+if (-not (Test-Path $vswhere)) {
+  throw "vswhere.exe not found; install Visual Studio with the C++ build tools."
+}
+
+$vsPath = (& $vswhere -latest -products * -requires $component -property installationPath |
+  Select-Object -First 1)
+if ($vsPath) { $vsPath = $vsPath.Trim() }
+if (-not $vsPath -or -not (Test-Path $vsPath)) {
+  throw "Visual Studio C++ build tools ($component) were not found."
+}
+
+# 2. Import the vcvarsall environment into this process and, in CI, the rest of
+#    the job. vcvarsall is locale-independent for KEY=VALUE output.
+$vcvars = Join-Path $vsPath "VC\Auxiliary\Build\vcvarsall.bat"
+if (-not (Test-Path $vcvars)) { throw "vcvarsall.bat not found at $vcvars" }
+foreach ($line in (cmd /c "`"$vcvars`" $arch && set")) {
+  if ($line -match "^([^=]+)=(.*)$") {
+    $name = $matches[1]
+    $value = $matches[2]
+    Set-Item -Path "Env:$name" -Value $value
+    Write-GitHubEnv $name $value
+  }
+}
+
+# 3. Use the LLVM bundled with that Visual Studio installation. This is the
+#    same compiler the driver and the build scripts resolve locally; the
+#    fallback handles installations that put LLVM at the VC\Tools\Llvm root.
+$llvmBin = Join-Path $vsPath "VC\Tools\Llvm\$llvmArch\bin"
+if (-not (Test-Path (Join-Path $llvmBin "clang.exe"))) {
+  $llvmBin = Join-Path $vsPath "VC\Tools\Llvm\bin"
+}
+$clang = Join-Path $llvmBin "clang.exe"
+if (-not (Test-Path $clang)) {
+  throw @"
+Visual Studio at $vsPath has no LLVM at $llvmBin.
+Install the "C++ Clang tools for Windows" component (Microsoft.VisualStudio.Component.VC.Llvm.Clang).
+"@
+}
+
+$versionOutput = & $clang --version
+if ($LASTEXITCODE -ne 0) { throw "$clang --version failed." }
+$versionLine = ($versionOutput | Select-Object -First 1).Trim()
+if ($versionLine -notmatch "clang version (\d+)\.") {
+  throw "$clang did not report a clang version: $versionLine"
+}
+$major = [int]$matches[1]
+if ($major -lt 16) {
+  throw "Visual Studio's clang is $versionLine; xbintsc requires clang 16 or newer."
+}
+$targetLine = $versionOutput | Where-Object { $_ -match "^Target:" } | Select-Object -First 1
+if (-not $targetLine -or $targetLine -notmatch "windows-msvc") {
+  throw "Visual Studio's clang targets '$targetLine', not the MSVC ABI."
+}
+$expectedTarget = if ($arch -eq "arm64") { "aarch64-pc-windows-msvc" } else { "x86_64-pc-windows-msvc" }
+if ($targetLine -notmatch [regex]::Escape($expectedTarget)) {
+  throw "Visual Studio's clang targets '$targetLine'; this runner is $arch (expected $expectedTarget)."
+}
+
+# 4. Put it in front of PATH and tell the driver exactly which clang to use.
+$env:xbintsc_CLANG = $clang
+$env:Path = "$llvmBin;$env:Path"
+Write-GitHubEnv "xbintsc_CLANG" $clang
+Write-GitHubPath $llvmBin
+
+# 5. Optional: GNU make for FFmpeg's configure (media archive only).
+if ($InstallMake) {
+  if ($env:GITHUB_ACTIONS) {
+    choco install make --no-progress -y
+    if ($LASTEXITCODE -ne 0) { throw "choco install make failed" }
+    $makePath = "C:\ProgramData\chocolatey\bin\make.exe"
+    if (-not (Test-Path $makePath)) { throw "GNU make was not installed at $makePath" }
+  } else {
+    $makeCommand = Get-Command make -ErrorAction SilentlyContinue
+    if (-not $makeCommand) {
+      throw "GNU make not found; install it (choco install make) or run without -InstallMake."
+    }
+    $makePath = $makeCommand.Source
+  }
+  $env:xbintsc_MAKE = $makePath
+  Write-GitHubEnv "xbintsc_MAKE" $makePath
+  $makeVersion = (& $makePath --version | Select-Object -First 1).Trim()
+  if ($makeVersion -notmatch "GNU Make") {
+    throw "$makePath is not GNU make: $makeVersion"
+  }
+  Write-Host "make         : $makePath ($makeVersion)"
+}
+
+Write-Host "Visual Studio: $vsPath"
+Write-Host "MSVC arch    : $arch"
+Write-Host "clang        : $clang ($versionLine)"
+Write-Host "target       : $targetLine"

package/scripts/support-matrix.ts

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+/**
+ * Render `doc/support-matrix.md` and its Chinese mirror from the vendored
+ * test262 catalogue.
+ *
+ * The catalogue is executable evidence: `tests/conformance/test262.test.ts`
+ * compiles and runs every supported case (unmodified test262 files) and
+ * requires every unsupported case to fail with the listed diagnostic code.
+ * This script turns the same catalogue into the human-readable table, so the
+ * document cannot claim a feature the compiler does not exercise.
+ *
+ * Usage: npm run docs:matrix
+ */
+
+import { writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import {
+  SUPPORT_AREAS,
+  SUPPORTED_CASES,
+  UNSUPPORTED_CASES,
+  type SupportArea,
+} from "../tests/conformance/test262/manifest.js";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+type Language = "en" | "zh";
+
+export const MATRIX_FILES: Readonly<Record<Language, string>> = {
+  en: "doc/support-matrix.md",
+  zh: "doc/zh-CN/support-matrix.md",
+};
+
+export const TEST262_COMMIT = "d53ebc8b1931d9f1541e43d59650776e4b766248";
+
+function docLink(area: SupportArea, language: Language): string {
+  const relative = area.doc.startsWith("doc/") ? area.doc.slice("doc/".length) : area.doc;
+  return language === "en" ? relative : `../${relative}`;
+}
+
+function areaTitle(area: SupportArea, language: Language): string {
+  return language === "en" ? area.title : area.titleZh;
+}
+
+function count(area: SupportArea, cases: readonly { readonly area: string }[]): number {
+  return cases.filter((testCase) => testCase.area === area.id).length;
+}
+
+function rowsFor(language: Language): string {
+  return SUPPORT_AREAS.map((area) => {
+    const supported = count(area, SUPPORTED_CASES);
+    const unsupported = count(area, UNSUPPORTED_CASES);
+    return `| ${areaTitle(area, language)} | ${supported} | ${unsupported} | [${language === "en" ? "reference" : "参考"}](${docLink(area, language)}) |`;
+  }).join("\n");
+}
+
+function supportedTable(language: Language): string {
+  const header =
+    language === "en"
+      ? "| test262 case | Area | What it pins down |\n| --- | --- | --- |"
+      : "| test262 用例 | 领域 | 固化的行为 |\n| --- | --- | --- |";
+  const rows = SUPPORTED_CASES.map((testCase) => {
+    const area = SUPPORT_AREAS.find((candidate) => candidate.id === testCase.area)!;
+    const claim = language === "en" ? testCase.claim : testCase.claimZh;
+    return `| \`${testCase.path}\` | ${areaTitle(area, language)} | ${claim} |`;
+  });
+  return [header, ...rows].join("\n");
+}
+
+function unsupportedTable(language: Language): string {
+  const header =
+    language === "en"
+      ? "| test262 case | Area | Diagnostic | Why |\n| --- | --- | ---: | --- |"
+      : "| test262 用例 | 领域 | 诊断码 | 原因 |\n| --- | --- | ---: | --- |";
+  const rows = UNSUPPORTED_CASES.map((testCase) => {
+    const area = SUPPORT_AREAS.find((candidate) => candidate.id === testCase.area)!;
+    const claim = language === "en" ? testCase.claim : testCase.claimZh;
+    return `| \`${testCase.path}\` | ${areaTitle(area, language)} | TS${testCase.code} | ${claim} |`;
+  });
+  return [header, ...rows].join("\n");
+}
+
+export function renderSupportMatrix(language: Language): string {
+  const corpusLink =
+    language === "en" ? "../tests/conformance/test262/manifest.ts" : "../../tests/conformance/test262/manifest.ts";
+  const testLink =
+    language === "en" ? "../tests/conformance/test262.test.ts" : "../../tests/conformance/test262.test.ts";
+  const sourceLink =
+    language === "en" ? "../tests/conformance/test262/SOURCE.md" : "../../tests/conformance/test262/SOURCE.md";
+
+  if (language === "en") {
+    return `# Support matrix
+
+> Language: **English** | [简体中文](./zh-CN/support-matrix.md)
+
+> **Generated** by \`npm run docs:matrix\` from the executable catalogue in
+> [\`tests/conformance/test262/manifest.ts\`](${corpusLink}). Do not edit this
+> file by hand: change a case and regenerate.
+
+Every supported case is an unmodified [test262](https://github.com/tc39/test262)
+file (pinned at \`${TEST262_COMMIT}\`) that xbintsc compiles **and runs**; the
+[test262 suite](${testLink}) fails if one stops passing. The corpus is a
+representative subset, not a full test262 run. Every unsupported case
+is valid JavaScript that xbintsc currently rejects, pinned with the diagnostic
+code it produces. See [\`SOURCE.md\`](${sourceLink}) for the harness adaptation.
+Because the suite runs on every CI platform, this table cannot claim more than
+the compiler does.
+
+## Coverage by area
+
+| Area | Supported | Unsupported | Reference |
+| --- | ---: | ---: | --- |
+${rowsFor(language)}
+
+## Supported cases (test262, compiled and executed)
+
+${supportedTable(language)}
+
+## Unsupported cases (valid JavaScript, expected diagnostics)
+
+${unsupportedTable(language)}
+`;
+  }
+
+  return `# 支持矩阵
+
+> 语言：[English](../support-matrix.md) | **简体中文**
+
+> 本文件由 \`npm run docs:matrix\` 根据可执行语料
+> [\`tests/conformance/test262/manifest.ts\`](${corpusLink}) 生成，请勿手工编辑：
+> 修改用例后重新生成。
+
+每个“支持”用例都是 [test262](https://github.com/tc39/test262) 的原始文件
+（固定版本 \`${TEST262_COMMIT}\`），由 xbintsc 编译**并执行**；
+[test262 测试套件](${testLink}) 会在用例回归时失败。该语料是代表性
+子集，不是完整的 test262 全量运行。每个“不支持”用例都是
+xbintsc 目前会拒绝的合法 JavaScript，并以实际产生的诊断码固定下来。
+harness 的适配说明见 [\`SOURCE.md\`](${sourceLink})。该套件在 CI 的每个平台
+运行，因此本表不会声称编译器做不到的能力。
+
+## 各领域覆盖
+
+| 领域 | 支持 | 不支持 | 参考 |
+| --- | ---: | ---: | --- |
+${rowsFor(language)}
+
+## 支持的用例（test262，编译并执行）
+
+${supportedTable(language)}
+
+## 不支持的用例（合法 JavaScript，预期诊断）
+
+${unsupportedTable(language)}
+`;
+}
+
+function main(): void {
+  for (const language of ["en", "zh"] as const) {
+    const path = resolve(root, MATRIX_FILES[language]);
+    writeFileSync(path, renderSupportMatrix(language));
+    process.stdout.write(`xbintsc: wrote ${MATRIX_FILES[language]}\n`);
+  }
+}
+
+if (process.argv[1] !== undefined && pathToFileURL(resolve(process.argv[1])).href === import.meta.url) {
+  main();
+}

package/src/ast/common.ts

@@ -33,6 +33,7 @@ import type {
   PropertyAccessExpression,
   RegularExpressionLiteral,
   SatisfiesExpression,
+  SequenceExpression,
   SpreadElement,
   StringLiteral,
   TaggedTemplateExpression,
@@ -143,6 +144,7 @@ export type Expression =
   | ConditionalExpression
   | AsExpression
   | SatisfiesExpression
+  | SequenceExpression
   | NonNullExpression
   | TypeOfExpression
   | VoidExpression

package/src/ast/declarations.ts

@@ -75,7 +75,11 @@ export interface ExpressionWithTypeArguments extends Node {
   readonly typeArguments: TypeNode[];
 }
 
-export type ClassElement = PropertyDeclaration | MethodDeclaration | ConstructorDeclaration;
+export type ClassElement =
+  | PropertyDeclaration
+  | MethodDeclaration
+  | ConstructorDeclaration
+  | ClassStaticBlockDeclaration;
 
 export interface PropertyDeclaration extends Node {
   readonly kind: SyntaxKind.PropertyDeclaration;
@@ -108,6 +112,13 @@ export interface ConstructorDeclaration extends Node {
   readonly body?: Block;
 }
 
+/** `static { ... }`: runs once, while the class is being defined. */
+export interface ClassStaticBlockDeclaration extends Node {
+  readonly kind: SyntaxKind.ClassStaticBlockDeclaration;
+  readonly modifiers: Modifier[];
+  readonly body: Block;
+}
+
 export interface ClassDeclaration extends Node {
   readonly kind: SyntaxKind.ClassDeclaration;
   readonly name?: Identifier;

package/src/ast/expressions.ts

@@ -206,6 +206,12 @@ export interface ParenthesizedExpression extends Node {
   readonly expression: Expression;
 }
 
+/** `a, b, c`: evaluates every operand left to right, yields the last value. */
+export interface SequenceExpression extends Node {
+  readonly kind: SyntaxKind.SequenceExpression;
+  readonly expressions: Expression[];
+}
+
 export interface PrefixUnaryExpression extends Node {
   readonly kind: SyntaxKind.PrefixUnaryExpression;
   readonly operator: PrefixUnaryOperator;

package/src/ast/kinds.ts

@@ -63,6 +63,7 @@ export const enum SyntaxKind {
   ObjectBindingPattern = 47,
   BindingElement = 48,
   ComputedPropertyName = 49,
+  SequenceExpression = 50,
 
   // Statements
   ExpressionStatement = 60,
@@ -112,6 +113,7 @@ export const enum SyntaxKind {
   ExportAssignment = 119,
   NamedExports = 120,
   ExportSpecifier = 121,
+  ClassStaticBlockDeclaration = 122,
 
   // Types
   TypeReference = 200,

package/src/binder/binder.ts

@@ -20,6 +20,7 @@ import type { Identifier, Node, SourceFileNode } from "../ast/nodes.js";
 import {
   ScopeKind,
   type ClassInfo,
+  type DeclarationConflict,
   type FunctionInfo,
   type MutableFunction,
   type Scope,
@@ -45,6 +46,7 @@ export class Binder {
   readonly symbolOfIdentifier = new Map<Identifier, SymbolInfo>();
   readonly scopes = new Map<Node, Scope>();
   readonly unresolved: Identifier[] = [];
+  readonly conflicts: DeclarationConflict[] = [];
   nextSymbolId = 1;
   nextFunctionId = 1;
   nextClassId = 1;
@@ -83,6 +85,7 @@ export class Binder {
       symbolOfIdentifier: this.symbolOfIdentifier,
       scopes: this.scopes,
       unresolved: this.unresolved,
+      conflicts: this.conflicts,
     };
   }
 

package/src/binder/declarations.ts

@@ -20,6 +20,71 @@ import { SymbolKind, type MutableFunction, type Scope, type SymbolInfo } from ".
 import { childNodes } from "./helpers.js";
 import type { Binder } from "./binder.js";
 
+/** Kinds that only introduce a type name, never a runtime binding. */
+const TYPE_ONLY_KINDS: ReadonlySet<SymbolKind> = new Set([
+  SymbolKind.Interface,
+  SymbolKind.TypeAlias,
+]);
+
+function isVarLike(kind: SymbolKind): boolean {
+  return kind === SymbolKind.Var || kind === SymbolKind.Function;
+}
+
+/**
+ * Whether a declaration of `next` may legally share a scope with `existing`.
+ *
+ * This is JavaScript's redeclaration rules plus TypeScript's declaration
+ * merging, kept deliberately explicit: a wrong `true` would hide a real bug, a
+ * wrong `false` would make valid code fail to compile. Only the cases this
+ * compiler can actually see are covered; anything unknown is treated as legal.
+ */
+export function declarationsCanMerge(existing: SymbolKind, next: SymbolKind): boolean {
+  if (existing === next) {
+    /* Repeated `var` / `function` / `interface` / `enum` declarations merge.
+     * Two imports may also share a name: bundling merges every module into one
+     * scope, and separate modules routinely import the same builtin
+     * (`readFileSync` from `node:fs`, `dirname` from `node:path`). The import
+     * map is keyed by symbol id, so keeping the first declaration is enough.
+     * `let`, `const`, `class` and parameters do not merge. */
+    return (
+      existing === SymbolKind.Var ||
+      existing === SymbolKind.Function ||
+      existing === SymbolKind.Interface ||
+      existing === SymbolKind.Namespace ||
+      existing === SymbolKind.Enum ||
+      existing === SymbolKind.Import
+    );
+  }
+  // `var` and `function` are both function-scoped and may coexist in any order.
+  if (isVarLike(existing) && isVarLike(next)) return true;
+  // `var` may redeclare a parameter; `let`/`const` may not.
+  if (
+    (existing === SymbolKind.Parameter && next === SymbolKind.Var) ||
+    (existing === SymbolKind.Var && next === SymbolKind.Parameter)
+  ) {
+    return true;
+  }
+  // Namespaces merge with classes, functions, enums and each other.
+  if (existing === SymbolKind.Namespace || next === SymbolKind.Namespace) return true;
+  // A class and an interface merge their instance shape.
+  if (
+    (existing === SymbolKind.Class && next === SymbolKind.Interface) ||
+    (existing === SymbolKind.Interface && next === SymbolKind.Class)
+  ) {
+    return true;
+  }
+  // An import binds both a value and a type name, so it conflicts with any
+  // same-name local declaration.
+  if (existing === SymbolKind.Import || next === SymbolKind.Import) return false;
+  // Value and type names live in separate declaration spaces, except classes
+  // and enums, which declare a type as well as a value.
+  if (TYPE_ONLY_KINDS.has(existing) !== TYPE_ONLY_KINDS.has(next)) {
+    const valueKind = TYPE_ONLY_KINDS.has(existing) ? next : existing;
+    return valueKind !== SymbolKind.Class && valueKind !== SymbolKind.Enum;
+  }
+  return false;
+}
+
 export interface DeclarationMethods {
   declareBinding(this: Binder, name: BindingName, kind: SymbolKind, declaration: Node, scope: Scope, mutable: boolean): SymbolInfo | undefined;
   declare(this: Binder, name: string, kind: SymbolKind, node: Node, scope: Scope, mutable: boolean): SymbolInfo;
@@ -60,6 +125,11 @@ export const declarationMethods: DeclarationMethods = {
   ): SymbolInfo {
     const existing = scope.symbols.get(name);
     if (existing) {
+      // `(anonymous)` is the binder's placeholder for `export default
+      // function () {}`; those have no user-visible name to collide.
+      if (name !== "(anonymous)" && !declarationsCanMerge(existing.kind, kind)) {
+        this.conflicts.push({ name, existing, kind, node });
+      }
       // `var` redeclarations and duplicate functions merge into one symbol.
       if (
         (kind === SymbolKind.Var && existing.kind === SymbolKind.Var) ||

package/src/binder/references.ts

@@ -33,7 +33,9 @@ import type { ArrayBindingPattern, ObjectBindingPattern, Parameter } from "../as
 import {
   ScopeKind,
   SymbolKind,
+  type ClassFieldInfo,
   type ClassInfo,
+  type ClassStaticInit,
   type FunctionInfo,
   type FunctionNode,
   type MutableFunction,
@@ -136,6 +138,23 @@ export const referenceMethods: ReferenceMethods = {
       case SyntaxKind.LabeledStatement:
         this.bindNode((node as unknown as { statement: Node }).statement, scope);
         return;
+      case SyntaxKind.SwitchStatement: {
+        const statement = node as unknown as {
+          expression: Expression;
+          clauses: { expression?: Expression; statements: Statement[] }[];
+        };
+        this.bindNode(statement.expression, scope);
+        /* Every `case` body shares the switch's block scope, so the
+         * declarations they contain have to be pre-declared before any clause
+         * is bound. Without this a `const` declared directly in a `case`
+         * clause had no symbol and later phases crashed on it. */
+        for (const clause of statement.clauses) {
+          this.bindNode(clause.expression, scope);
+          this.predeclareStatements(clause.statements, scope);
+        }
+        for (const clause of statement.clauses) this.bindStatements(clause.statements, scope);
+        return;
+      }
       case SyntaxKind.BreakStatement:
       case SyntaxKind.ContinueStatement:
         return;
@@ -150,6 +169,15 @@ export const referenceMethods: ReferenceMethods = {
       case SyntaxKind.TypeAliasDeclaration:
         // Type-only: skip the body entirely.
         return;
+      case SyntaxKind.EnumDeclaration: {
+        /* Member names are keys of the generated object, not bindings; only an
+         * initializer (`A = foo()`) contains runtime references. */
+        const members = (node as unknown as { members: { initializer?: Expression }[] }).members;
+        for (const member of members) {
+          if (member.initializer) this.bindNode(member.initializer, scope);
+        }
+        return;
+      }
       case SyntaxKind.ImportDeclaration:
         return;
       case SyntaxKind.ExportDeclaration: {
@@ -204,6 +232,22 @@ export const referenceMethods: ReferenceMethods = {
         this.bindBlock(clause.block, catchScope);
         return;
       }
+      /* Type positions are erased, so their identifiers are not runtime
+       * references. Walking them would put `Foo` from `x as Foo` or the type
+       * arguments of `f<Foo>()` into `unresolved`, and the checker would then
+       * report a value that never exists. */
+      case SyntaxKind.AsExpression:
+      case SyntaxKind.SatisfiesExpression:
+      case SyntaxKind.NonNullExpression:
+        this.bindNode((node as unknown as { expression: Expression }).expression, scope);
+        return;
+      case SyntaxKind.CallExpression:
+      case SyntaxKind.NewExpression: {
+        const call = node as unknown as { expression: Expression; arguments: Expression[] };
+        this.bindNode(call.expression, scope);
+        for (const argument of call.arguments) this.bindNode(argument, scope);
+        return;
+      }
       default:
         break;
     }
@@ -211,10 +255,24 @@ export const referenceMethods: ReferenceMethods = {
   },
 
   bindVariableList(list: VariableDeclarationList, scope: Scope): void {
+    const declarationKind =
+      list.declarationKind === "const"
+        ? SymbolKind.Const
+        : list.declarationKind === "var"
+          ? SymbolKind.Var
+          : SymbolKind.Let;
     for (const declaration of list.declarations) {
-      const symbol = this.symbolOfDeclaration.get(declaration);
       if (declaration.name.kind === SyntaxKind.Identifier) {
-        this.symbolOfDeclaration.set(declaration.name, symbol ?? this.symbolOfDeclaration.get(declaration) as SymbolInfo);
+        /* Normally the declaration was pre-declared; if it was not (a code
+         * path that binds statements without pre-declaring them), declare it
+         * here rather than storing an empty entry that later phases would
+         * dereference. */
+        const name = declaration.name as Identifier;
+        const symbol =
+          this.symbolOfDeclaration.get(declaration) ??
+          this.symbolOfDeclaration.get(name) ??
+          this.declareBinding(name, declarationKind, declaration, scope, declarationKind !== SymbolKind.Const);
+        if (symbol) this.symbolOfDeclaration.set(name, symbol);
       } else {
         this.bindBindingPattern(declaration.name, scope);
       }
@@ -329,6 +387,8 @@ export const referenceMethods: ReferenceMethods = {
       fields: [],
       methods: [],
       statics: [],
+      staticBlocks: [],
+      staticInit: [],
     };
     this.classes.push(info);
     this.classOfNode.set(node, info);
@@ -337,6 +397,9 @@ export const referenceMethods: ReferenceMethods = {
     this.scopes.set(node, classScope);
 
     let constructor: FunctionInfo | undefined;
+    /* `static { ... }` functions, so the field pass below can interleave them
+     * with static fields in declaration order. */
+    const staticBlockFns = new Map<Node, FunctionInfo>();
     for (const member of node.members) {
       if (member.kind === SyntaxKind.ConstructorDeclaration) {
         const ctor = member as ConstructorDeclaration;
@@ -354,6 +417,14 @@ export const referenceMethods: ReferenceMethods = {
         }
         if (isStatic) (info.statics as FunctionInfo[]).push(fn);
         else (info.methods as FunctionInfo[]).push(fn);
+      } else if (member.kind === SyntaxKind.ClassStaticBlockDeclaration) {
+        /* A static block is a function-like body: it runs once with `this`
+         * bound to the class, so it is bound like a static method and called
+         * right after the class value is built. */
+        const block = member as unknown as { body: Block };
+        const fn = this.createClassFunction(member, "static", [], block.body, classScope, info, true, false);
+        (info.staticBlocks as FunctionInfo[]).push(fn);
+        staticBlockFns.set(member, fn);
       }
     }
     if (!constructor) {
@@ -371,7 +442,17 @@ export const referenceMethods: ReferenceMethods = {
         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 });
+        const field: ClassFieldInfo = {
+          name: classMemberName(property.name),
+          initializer: property.initializer,
+          fn: constructor,
+          isStatic,
+        };
+        (info.fields as ClassFieldInfo[]).push(field);
+        if (isStatic) (info.staticInit as ClassStaticInit[]).push({ kind: "field", field });
+      } else if (member.kind === SyntaxKind.ClassStaticBlockDeclaration) {
+        const fn = staticBlockFns.get(member);
+        if (fn) (info.staticInit as ClassStaticInit[]).push({ kind: "block", fn });
       }
     }
 
@@ -429,7 +510,19 @@ export const referenceMethods: ReferenceMethods = {
         this.symbolOfIdentifier.set(identifier, symbol);
         // Functions, classes and type-only names are resolved to their
         // declaration sites by codegen; they are never captured as values.
-        if (symbol.fn !== this.current && isCapturable(symbol.kind)) this.markCaptured(symbol);
+        // A *function declaration* reached from a nested function is the
+        // exception: the closure value belongs to the declaring function's
+        // frame (it may itself capture parameters), so thread it through the
+        // environment instead of rebuilding it at the call site with the
+        // caller's slots. Module-scope functions keep their global handling.
+        if (symbol.kind === SymbolKind.Function) {
+          /* Module-scope functions are reached through their globals; a
+           * function declared inside a function travels with the closure
+           * environment because its own captures belong to that frame. */
+          if (symbol.fn !== this.current && !symbol.fn.isModule) this.markCaptured(symbol);
+        } else if (symbol.fn !== this.current && isCapturable(symbol.kind)) {
+          this.markCaptured(symbol);
+        }
         return;
       }
       current = current.parent;