xbintsc 0.5.23 → 0.5.31

package/src/extensions/registry.ts

@@ -17,6 +17,23 @@ export interface BuiltinFunction {
   readonly returnVoid?: boolean;
 }
 
+/**
+ * A global *value* rather than a function: the name resolves to whatever a
+ * runtime getter returns, so `window`, `document` or a host constructor
+ * (`new AudioContext()`) can be reached without declaring them in the source.
+ *
+ * `symbol` has the usual `(int32_t argc, xt_value *argv)` ABI and is called
+ * with no arguments, or with one argument when `argument` is set (that is how
+ * a host hands a single getter a type name such as `"HTMLCanvasElement"`).
+ * `new Name(...)` lowers to the getter followed by an ordinary `xt_new`, so a
+ * host constructor is just a global value that returns a function.
+ */
+export interface GlobalValue {
+  readonly symbol: string;
+  /** Passed as the only argument; omit to call the getter with none. */
+  readonly argument?: string;
+}
+
 /**
  * One binding a Node-style module exports. It is either a direct runtime
  * function with the uniform `(argc, argv)` ABI (`symbol`), or a named method
@@ -59,6 +76,14 @@ export interface AssetLoadResult {
    * contain its own `import`/`export` statements, which are followed normally.
    */
   readonly moduleSource: string;
+  /**
+   * Ranges of `moduleSource` that were copied verbatim from *another* file —
+   * for instance the body of `<script src="app.js">` wrapped by the `gui`
+   * `.html` loader. Nodes inside a range keep that file as their origin, so
+   * diagnostics name the file the user actually wrote and the checker's
+   * plain-JavaScript exemption still applies to a `.js` script.
+   */
+  readonly sourceRanges?: readonly AssetSourceRange[];
   /**
    * Extra files the transformed module depends on that are *not* reached
    * through imports (for cache invalidation). Imported files are already
@@ -67,6 +92,13 @@ export interface AssetLoadResult {
   readonly dependencies?: readonly string[];
 }
 
+/** A `[start, end)` span of a generated module copied from `file`. */
+export interface AssetSourceRange {
+  readonly start: number;
+  readonly end: number;
+  readonly file: string;
+}
+
 /** Rewrites an imported file (selected by extension) into a TS module. */
 export type AssetLoader = (path: string, source: string) => AssetLoadResult;
 
@@ -97,6 +129,12 @@ export interface Extension {
   linkerFlags?(): readonly string[];
   /** Global identifiers that resolve to runtime symbols when called. */
   builtins?(): Readonly<Record<string, BuiltinFunction>>;
+  /**
+   * Global identifiers that resolve to a runtime *value* (`window`,
+   * `document`, a host constructor). They need no declaration in the source
+   * and are not callable-by-name: reading the identifier calls the getter.
+   */
+  globalValues?(): Readonly<Record<string, GlobalValue>>;
   /** Modules importable as `import ... from "<specifier>"`. */
   modules?(): Readonly<Record<string, ExtensionModule>>;
   /**
@@ -191,6 +229,16 @@ export class ExtensionRegistry {
     return merged;
   }
 
+  /** Flatten every registered extension's global values into one lookup. */
+  globalValues(): Readonly<Record<string, GlobalValue>> {
+    const merged: Record<string, GlobalValue> = {};
+    for (const extension of this.extensions.values()) {
+      const values = extension.globalValues?.();
+      if (values) Object.assign(merged, values);
+    }
+    return merged;
+  }
+
   /** Flatten every registered extension's importable modules. */
   modules(): Readonly<Record<string, ExtensionModule>> {
     const merged: Record<string, ExtensionModule> = {};

package/src/index.ts

@@ -19,6 +19,7 @@ export { TokenKind, KEYWORDS, type Token } from "./lexer/token.js";
 export * from "./ast/nodes.js";
 export { Parser } from "./parser/parser.js";
 export { bind, SymbolKind, ScopeKind, type BindResult, type FunctionInfo, type SymbolInfo } from "./binder/binder.js";
+export { checkProgram, type CheckOptions } from "./checker/checker.js";
 export { generate, type CodegenResult, type CodegenOptions } from "./codegen/llvm.js";
 export {
   XT_UNDEFINED,

package/src/parser/declarations/classes.ts

@@ -85,6 +85,13 @@ export const declarationClassMethods: DeclarationClassMethods = {
       this.nextToken();
       return undefined;
     }
+    /* `static { ... }`: a block that runs once while the class is defined. The
+     * `static` keyword was already consumed by `tryParseModifiers`, so the
+     * initializer position is the only way to tell it apart from a member. */
+    if (this.at(TokenKind.OpenBrace) && this.hasModifier(modifiers, ModifierKind.Static)) {
+      const body = this.parseBlock();
+      return { kind: SyntaxKind.ClassStaticBlockDeclaration, modifiers, body, start, end: body.end };
+    }
     if (
       (this.at(TokenKind.GetKeyword) || this.at(TokenKind.SetKeyword)) &&
       !this.atAhead(1, TokenKind.OpenParen) &&

package/src/parser/expressions.ts

@@ -61,7 +61,19 @@ export interface ExpressionMethods {
 
 export const expressionMethods: ExpressionMethods = {
   parseExpression(this: Parser, noIn = false): Expression {
-    return this.parseAssignmentExpression(noIn);
+    const first = this.parseAssignmentExpression(noIn);
+    if (!this.at(TokenKind.Comma)) return first;
+    const expressions: Expression[] = [first];
+    while (this.at(TokenKind.Comma)) {
+      this.nextToken();
+      expressions.push(this.parseAssignmentExpression(noIn));
+    }
+    return {
+      kind: SyntaxKind.SequenceExpression,
+      expressions,
+      start: first.start,
+      end: expressions[expressions.length - 1]!.end,
+    };
   },
 
   parseAssignmentExpression(this: Parser, noIn = false): Expression {

package/src/parser/literals.ts

@@ -159,8 +159,12 @@ export const literalMethods: LiteralMethods = {
   },
 
   parseFunctionExpression(this: Parser): FunctionExpression {
-    const start = this.parseExpected(TokenKind.FunctionKeyword).start;
-    let flags = NodeFlags.None;
+    /* `async function (...) {}` is an expression too; the `async` keyword is
+     * part of this node rather than a modifier list. */
+    const asyncToken = this.at(TokenKind.AsyncKeyword) ? this.nextToken() : undefined;
+    const functionToken = this.parseExpected(TokenKind.FunctionKeyword);
+    const start = asyncToken ? asyncToken.start : functionToken.start;
+    let flags = asyncToken ? NodeFlags.Async : NodeFlags.None;
     if (this.at(TokenKind.Asterisk)) {
       this.nextToken();
       flags |= NodeFlags.Generator;