xbintsc 0.5.6 → 0.5.21

package/src/extensions/node/fs-promises/index.ts

@@ -1,11 +1,11 @@
 /**
  * Node's `fs/promises` module.
  *
- * There is no asynchronous I/O scheduler, so each function wraps the matching
- * synchronous `fs` implementation in an already-settled promise (rejected on
- * failure). `readFile`, `writeFile`, `mkdir`, `readdir`, `stat`, `rm`,
- * `open` (a `FileHandle`), ... are therefore importable from `fs/promises`.
- * `constants` is re-exported as a value getter.
+ * Each function submits a job to the asynchronous I/O pool: the blocking
+ * syscall runs on a worker thread and the promise settles on the event loop, so
+ * awaiting `readFile`, `writeFile`, `stat`, `rm`, `open` (a `FileHandle`), ...
+ * yields to timers and sockets while the I/O is in flight. `constants` is
+ * re-exported as a value getter.
  */
 
 import type { NodeModule } from "../module.js";
@@ -54,7 +54,7 @@ const exports: ModuleExports = {
 export const fsPromisesModule: NodeModule = {
   name: "fs/promises",
   runtimeSources: () => [
-    // Reuse the synchronous fs implementations the promise wrappers delegate to.
+    // Synchronous builtins (used by `watch` and the sync module) plus the async job split.
     resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/read_file.c"),
     resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/write_file.c"),
     resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/fs_ops.c"),
@@ -63,6 +63,15 @@ export const fsPromisesModule: NodeModule = {
     resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/link_ops.c"),
     resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/copy_ops.c"),
     resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/constants.c"),
+    resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/dir.c"),
+    resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/watch.c"),
+    resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/async_job.c"),
+    resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/async_worker.c"),
+    resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/async_worker_dir.c"),
+    resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/async_worker_fd.c"),
+    resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/async_complete.c"),
+    resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/async_api.c"),
+    resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/async_fh.c"),
     resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/promises.c"),
   ],
   builtins: () => builtins,

package/src/parser/declarations/classes.ts

@@ -38,6 +38,10 @@ export const declarationClassMethods: DeclarationClassMethods = {
     let name: Identifier | undefined;
     if (!this.at(TokenKind.OpenBrace) && !this.at(TokenKind.ExtendsKeyword) && !this.at(TokenKind.ImplementsKeyword)) {
       name = this.parseIdentifier();
+    } else if (this.hasModifier(modifiers, ModifierKind.Default)) {
+      /* `export default class {}` gets the internal binding name the bundler
+       * maps the default export to. */
+      name = { kind: SyntaxKind.Identifier, text: "default", start, end: start };
     }
     const typeParameters = this.parseTypeParameters();
     const heritage = this.parseHeritageClauses();

package/src/parser/declarations/functions.ts

@@ -19,6 +19,7 @@ import {
   type TypeParameterDeclaration,
 } from "../../ast/nodes.js";
 import type { BindingElement, BindingName } from "../../ast/declarations.js";
+import { DiagnosticCode } from "../../diagnostics/diagnostic.js";
 import { expressionToPropertyName } from "../helpers.js";
 import type { Parser } from "../parser.js";
 
@@ -43,7 +44,17 @@ export const declarationFunctionMethods: DeclarationFunctionMethods = {
     if (this.hasModifier(modifiers, ModifierKind.Async)) flags |= NodeFlags.Async;
     if (this.hasModifier(modifiers, ModifierKind.Declare)) flags |= NodeFlags.Declare;
     let name: Identifier | undefined;
-    if (!this.at(TokenKind.OpenParen) && !this.at(TokenKind.LessThan)) name = this.parseIdentifier();
+    if (!this.at(TokenKind.OpenParen) && !this.at(TokenKind.LessThan)) {
+      name = this.parseIdentifier();
+    } else if (this.hasModifier(modifiers, ModifierKind.Default)) {
+      /* `export default function () {}` is the one valid anonymous form. Give
+       * it the internal binding name the default export is mapped to, so the
+       * bundler can export it like `export default <expression>`. */
+      name = { kind: SyntaxKind.Identifier, text: "default", start, end: start };
+    } else {
+      /* A plain `function () {}` is not a declaration. */
+      this.error(DiagnosticCode.ExpectedIdentifier, "Function declaration needs a name");
+    }
     const typeParameters = this.parseTypeParameters();
     const parameters = this.parseParameters();
     let returnType: TypeNode | undefined;

package/src/parser/modules.ts

@@ -2,7 +2,7 @@
  * Import and export declaration parsing.
  */
 
-import { TokenKind } from "../lexer/token.js";
+import { TokenKind, type Token } from "../lexer/token.js";
 import {
   ModifierKind,
   SyntaxKind,
@@ -33,7 +33,11 @@ export const moduleMethods: ModuleMethods = {
   parseImportDeclaration(this: Parser): ImportDeclaration {
     const start = this.parseExpected(TokenKind.ImportKeyword).start;
     let importClause: ImportClause | undefined;
-    if (!this.at(TokenKind.StringLiteral)) {
+    let moduleToken: Token;
+    if (this.at(TokenKind.StringLiteral)) {
+      // `import "mod";` evaluates the module for its side effects only.
+      moduleToken = this.nextToken();
+    } else {
       const clauseStart = this.token.start;
       let isTypeOnly = false;
       if (this.at(TokenKind.TypeKeyword) && !this.lookAhead(1).precededByLineBreak) {
@@ -58,9 +62,9 @@ export const moduleMethods: ModuleMethods = {
         namedBindings = this.parseNamedImports();
       }
       importClause = { kind: SyntaxKind.ImportClause, name, namedBindings, isTypeOnly, start: clauseStart, end: namedBindings?.end ?? name?.end ?? clauseStart };
+      this.parseExpected(TokenKind.FromKeyword);
+      moduleToken = this.parseExpected(TokenKind.StringLiteral);
     }
-    this.parseExpected(TokenKind.FromKeyword);
-    const moduleToken = this.parseExpected(TokenKind.StringLiteral);
     const moduleSpecifier = this.stringLiteralFromToken(moduleToken);
     const attributes: { name: string; value: string }[] = [];
     if (this.at(TokenKind.WithKeyword) || (this.at(TokenKind.Identifier) && this.token.text === "assert")) {

package/src/parser/parser.ts

@@ -21,6 +21,34 @@ import { typeMethods, type TypeMethods } from "./types.js";
 
 export class Parser extends ParserContext {
   parseSourceFile(): SourceFileNode {
+    try {
+      return this.parseSourceFileBody();
+    } catch (error) {
+      /* Deeply nested input (thousands of `(`, arrays, type arguments, ...)
+       * exhausts the JavaScript stack before the recursive-descent parser can
+       * produce a syntax error. Report it as a diagnostic instead of letting a
+       * raw RangeError escape as an "internal error" with no location. */
+      if (error instanceof RangeError && /call stack|stack size/i.test(error.message)) {
+        this.diagnostics.error(
+          DiagnosticCode.NestingTooDeep,
+          "Source is nested too deeply to parse; reduce the nesting depth (for example, split the expression)",
+          { start: this.token.start, end: this.token.end },
+          this.source.fileName,
+        );
+        return {
+          kind: SyntaxKind.SourceFile,
+          statements: [],
+          fileName: this.source.fileName,
+          text: this.source.text,
+          start: 0,
+          end: this.source.text.length,
+        };
+      }
+      throw error;
+    }
+  }
+
+  private parseSourceFileBody(): SourceFileNode {
     const statements: Statement[] = [];
     while (!this.at(TokenKind.EndOfFile)) {
       const before = this.consumed;