👍 Improve stability on unexpected errors

Author: lambdalisue

autoload/fall/internal.vim

@@ -2,5 +2,5 @@ function! fall#internal#dispatch(event) abort
   if denops#plugin#wait('fall') isnot# 0
     return
   endif
-  call denops#request('fall', 'event:dispatch', [a:event])
+  call denops#notify('fall', 'event:dispatch', [a:event])
 endfunction

denops/fall/event.ts

@@ -7,15 +7,15 @@ export function dispatch(event: Readonly<Event>): void {
 }
 
 export function consume(consumer: Consumer): void {
-  for (const event of eventQueue) {
-    consumer(event);
-  }
+  const events = eventQueue;
   eventQueue = [];
+  events.forEach(consumer);
 }
 
 type SelectMethod = "on" | "off" | "toggle";
 
 export type Event =
+  | { type: "debug-error"; message: string }
   | { type: "vim-resized"; width: number; height: number }
   | { type: "vim-cmdline-changed"; cmdline: string }
   | { type: "vim-cmdpos-changed"; cmdpos: number }

denops/fall/lib/scheduler.ts

@@ -8,30 +8,33 @@ export class Scheduler implements Disposable {
 
   #tick(
     callback: () => void | Promise<void>,
-    { signal }: { signal?: AbortSignal } = {},
+    { reject, signal }: {
+      reject: (reason: unknown) => void;
+      signal?: AbortSignal;
+    },
   ): void {
     this.#timer = setTimeout(async () => {
       if (!this.#timer || signal?.aborted) return;
       try {
         await callback();
         if (!this.#timer || signal?.aborted) return;
-        this.#tick(callback, { signal });
+        this.#tick(callback, { reject, signal });
       } catch (err) {
-        if (err instanceof DOMException && err.name === "AbortError") return;
-        const m = err instanceof Error ? err.message : String(err);
-        console.error(`[fall] Unexpected error in Scheduler: ${m}`);
+        reject(err);
       }
     }, this.#interval);
   }
 
   start(
     callback: () => void | Promise<void>,
     { signal }: { signal?: AbortSignal } = {},
-  ): void {
+  ): Promise<never> {
     if (this.#timer !== undefined) {
-      throw new Error("Scheduler is already started");
+      return Promise.reject(new Error("Scheduler is already started"));
     }
-    this.#tick(callback, { signal });
+    return new Promise((_, reject) => {
+      this.#tick(callback, { reject, signal });
+    });
   }
 
   stop(): void {

denops/fall/main/event.ts

@@ -21,6 +21,10 @@ function eventDispatch(event: unknown): void {
 // Only event that is dispatched from Vim requires predicate function.
 // So this is NOT a full list of event types.
 const isEventComplement = is.UnionOf([
+  is.ObjectOf({
+    type: is.LiteralOf("debug-error"),
+    message: is.String,
+  }),
   // Vim
   is.ObjectOf({
     type: is.LiteralOf("vim-resized"),

denops/fall/picker.ts

@@ -143,7 +143,7 @@ export class Picker<T> implements AsyncDisposable {
     { args }: { args: string[] },
     { signal }: { signal?: AbortSignal } = {},
   ): Promise<PickerResult<T> | undefined> {
-    using stack = new DisposableStack();
+    await using stack = new AsyncDisposableStack();
 
     this.#collectProcessor.start(denops, { args });
     stack.defer(() => this.#collectProcessor.pause());
@@ -158,8 +158,8 @@ export class Picker<T> implements AsyncDisposable {
       cmdline: this.#inputComponent.cmdline,
       cmdpos: this.#inputComponent.cmdpos,
     });
-    using scheduler = new Scheduler(this.#schedulerInterval);
-    scheduler.start(async () => {
+    const scheduler = stack.use(new Scheduler(this.#schedulerInterval));
+    const waiter = scheduler.start(async () => {
       // Check cmdline/cmdpos
       await cmdliner.check(denops);
 
@@ -197,7 +197,11 @@ export class Picker<T> implements AsyncDisposable {
       }
     }, { signal });
 
-    const query = await cmdliner.input(denops, { signal });
+    stack.defer(() => Cmdliner.cancel(denops));
+    const query = await Promise.race([
+      cmdliner.input(denops, { signal }),
+      waiter,
+    ]);
     if (query == null) {
       return;
     }
@@ -278,6 +282,11 @@ export class Picker<T> implements AsyncDisposable {
     accept: (name: string) => Promise<void>;
   }): void {
     switch (event.type) {
+      case "debug-error":
+        console.log(
+          `[fall] 'debug-error' event has received: ${event.message}`,
+        );
+        throw new Error(event.message);
       case "vim-resized": {
         this.#resized = {
           width: event.width,

denops/fall/util/cmdliner.ts

@@ -18,6 +18,9 @@ export class Cmdliner {
 
   static async #feedkeys(denops: Denops, key: string): Promise<void> {
     try {
+      if (!(await fn.mode(denops)).startsWith("c")) {
+        return;
+      }
       await useEval(denops, async (denops) => {
         await fn.feedkeys(denops, key, "n");
       });
@@ -65,7 +68,7 @@ export class Cmdliner {
       fn.getcmdline(denops),
       fn.getcmdpos(denops),
     ]);
-    if (mode !== "c") {
+    if (!mode.startsWith("c")) {
       // Not in command-line mode
       return;
     }