adjust DisposableResult impl and union

Author: justjake

packages/quickjs-emscripten-core/src/QuickJSIterator.ts

@@ -1,8 +1,7 @@
-import type { QuickJSContext } from "./context"
-import { Lifetime, UsingDisposable } from "./lifetime"
+import type { ContextResult, QuickJSContext } from "./context"
+import { DisposableResult, Lifetime, UsingDisposable } from "./lifetime"
 import type { QuickJSRuntime } from "./runtime"
 import type { QuickJSHandle } from "./types"
-import type { VmCallResult } from "./vm-interface"
 
 /**
  * Proxies the iteration protocol from the host to a guest iterator.
@@ -29,7 +28,7 @@ import type { VmCallResult } from "./vm-interface"
  */
 export class QuickJSIterator
   extends UsingDisposable
-  implements Disposable, Iterator<VmCallResult<QuickJSHandle>>
+  implements Disposable, Iterator<ContextResult<QuickJSHandle>>
 {
   public owner: QuickJSRuntime
   private _next: QuickJSHandle | undefined
@@ -43,7 +42,7 @@ export class QuickJSIterator
     this.owner = context.runtime
   }
 
-  next(value?: QuickJSHandle): IteratorResult<VmCallResult<QuickJSHandle>, any> {
+  next(value?: QuickJSHandle): IteratorResult<ContextResult<QuickJSHandle>, any> {
     if (!this.alive || this._isDone) {
       return {
         done: true,
@@ -55,7 +54,7 @@ export class QuickJSIterator
     return this.callIteratorMethod(nextMethod, value)
   }
 
-  return(value?: QuickJSHandle): IteratorResult<VmCallResult<QuickJSHandle>, any> {
+  return(value?: QuickJSHandle): IteratorResult<ContextResult<QuickJSHandle>, any> {
     if (!this.alive) {
       return {
         done: true,
@@ -81,7 +80,7 @@ export class QuickJSIterator
     return result
   }
 
-  throw(e?: any): IteratorResult<VmCallResult<QuickJSHandle>, any> {
+  throw(e?: any): IteratorResult<ContextResult<QuickJSHandle>, any> {
     if (!this.alive) {
       return {
         done: true,
@@ -113,7 +112,7 @@ export class QuickJSIterator
   private callIteratorMethod(
     method: QuickJSHandle,
     input?: QuickJSHandle,
-  ): IteratorResult<VmCallResult<QuickJSHandle>, any> {
+  ): IteratorResult<ContextResult<QuickJSHandle>, any> {
     const callResult = input
       ? this.context.callFunction(method, this.handle, input)
       : this.context.callFunction(method, this.handle)
@@ -137,8 +136,8 @@ export class QuickJSIterator
     const value = this.context.getProp(callResult.value, "value")
     callResult.value.dispose()
     return {
-      value: { value },
-      done,
+      value: DisposableResult.success(value),
+      done: done as false,
     }
   }
 }

packages/quickjs-emscripten-core/src/context.ts

@@ -925,7 +925,7 @@ export class QuickJSContext
       const methodHandle = scope.manage(this.getProp(handle, SymbolIterator))
       const iteratorCallResult = this.callFunction(methodHandle, handle)
       if (iteratorCallResult.error) {
-        return iteratorCallResult.cast()
+        return iteratorCallResult
       }
       return this.success(new QuickJSIterator(iteratorCallResult.value, this))
     })

packages/quickjs-emscripten-core/src/lifetime.test.ts

@@ -1,6 +1,6 @@
 import assert from "assert"
 import { describe, it } from "vitest"
-import { Lifetime, Scope } from "./lifetime"
+import { DisposableResult, Lifetime, Scope } from "./lifetime"
 
 describe("Lifetime", () => {
   describe(".consume", () => {
@@ -57,3 +57,77 @@ describe("Scope", () => {
     })
   })
 })
+
+describe("DisposableResult", () => {
+  function itBehavesAsDisposable(factory: <T>(v: T) => DisposableResult<T, T>) {
+    it("is alive when the value is not disposable", () => {
+      const result = factory(false)
+      assert.strictEqual(result.alive, true)
+    })
+
+    it("is alive when the value is disposable and alive", () => {
+      const lifetime = new Lifetime(1)
+      const result = factory(lifetime)
+      assert.strictEqual(result.alive, true)
+      lifetime.dispose()
+      assert.strictEqual(result.alive, false)
+    })
+
+    it("disposes the value when dispose is called", () => {
+      const lifetime = new Lifetime(1)
+      const result = factory(lifetime)
+      result.dispose()
+      assert.strictEqual(lifetime.alive, false)
+    })
+
+    it("can call unwrapOr", () => {
+      const result = factory("hi")
+      result.unwrapOr(0)
+    })
+  }
+
+  describe("success", () => {
+    itBehavesAsDisposable((v) => DisposableResult.success(v))
+
+    it("unwrap returns the value", () => {
+      const val = {}
+      const result = DisposableResult.success(val)
+      assert.strictEqual(result.unwrap(), val)
+    })
+
+    it("unwrapOr returns the value", () => {
+      const val = {}
+      const result = DisposableResult.success(val)
+      assert.strictEqual(result.unwrapOr(0), val)
+    })
+  })
+
+  describe("fail", () => {
+    itBehavesAsDisposable((v) => DisposableResult.fail(v, () => {}))
+
+    it("unwrap calls the onUnwrap", () => {
+      let calledWith: unknown = undefined
+      const expectedError = new Error("will throw")
+      const result = DisposableResult.fail("error", (v) => {
+        calledWith = v
+        throw expectedError
+      })
+      assert.throws(
+        () => result.unwrap(),
+        (e) => e === expectedError,
+      )
+      assert.strictEqual(calledWith, result)
+    })
+
+    it("throws even if unwrap doesnt", () => {
+      const result = DisposableResult.fail("error", () => {})
+      assert.throws(() => result.unwrap())
+    })
+
+    it("unwrapOr returns the fallback", () => {
+      const fallback = {}
+      const result = DisposableResult.fail("error", () => {})
+      assert.strictEqual(result.unwrapOr(fallback), fallback)
+    })
+  })
+})

packages/quickjs-emscripten-core/src/lifetime.ts

@@ -1,4 +1,4 @@
-import { SuccessOrFail } from "./vm-interface"
+import type { SuccessOrFail } from "./vm-interface"
 import type { MaybeAsyncBlock } from "./asyncify-helpers"
 import { maybeAsync } from "./asyncify-helpers"
 import { QTS_DEBUG } from "./debug"
@@ -376,16 +376,16 @@ function isDisposable(value: unknown): value is { alive: boolean; dispose(): unk
   )
 }
 
-abstract class AbstractDisposableResult<S, F> extends UsingDisposable {
-  static success<S, F>(value: S): DisposableSuccess<S, F> {
+abstract class AbstractDisposableResult extends UsingDisposable implements Disposable {
+  static success<S, F>(value: S): DisposableSuccess<S> {
     return new DisposableSuccess(value) satisfies SuccessOrFail<S, F>
   }
 
-  static fail<S, F>(
-    error: F,
-    onUnwrap: (status: SuccessOrFail<S, F>) => void,
-  ): DisposableFail<S, F> {
-    return new DisposableFail(error, onUnwrap) satisfies SuccessOrFail<S, F>
+  static fail<S, F>(error: F, onUnwrap: (status: SuccessOrFail<S, F>) => void): DisposableFail<F> {
+    return new DisposableFail(
+      error,
+      onUnwrap as (status: SuccessOrFail<never, F>) => void,
+    ) satisfies SuccessOrFail<S, F>
   }
 
   static is<S, F>(result: SuccessOrFail<S, F>): result is DisposableResult<S, F> {
@@ -394,11 +394,9 @@ abstract class AbstractDisposableResult<S, F> extends UsingDisposable {
 
   abstract get alive(): boolean
   abstract dispose(): void
-  abstract unwrap(): S
-  abstract unwrapOr<T>(fallback: T): S | T
 }
 
-export class DisposableSuccess<S, F> extends AbstractDisposableResult<S, F> {
+export class DisposableSuccess<S> extends AbstractDisposableResult {
   declare error?: undefined
 
   constructor(readonly value: S) {
@@ -415,19 +413,19 @@ export class DisposableSuccess<S, F> extends AbstractDisposableResult<S, F> {
     }
   }
 
-  override unwrap(): S {
+  unwrap(): S {
     return this.value
   }
 
-  override unwrapOr<T>(_fallback: T): S | T {
+  unwrapOr<T>(_fallback: T): S | T {
     return this.value
   }
 }
 
-export class DisposableFail<S, F> extends AbstractDisposableResult<S, F> {
+export class DisposableFail<F> extends AbstractDisposableResult {
   constructor(
     readonly error: F,
-    private readonly onUnwrap: (status: SuccessOrFail<S, F>) => void,
+    private readonly onUnwrap: (status: SuccessOrFail<never, F>) => void,
   ) {
     super()
   }
@@ -437,22 +435,20 @@ export class DisposableFail<S, F> extends AbstractDisposableResult<S, F> {
   }
 
   override dispose(): void {
-    throw new Error("Method not implemented.")
+    if (isDisposable(this.error)) {
+      this.error.dispose()
+    }
   }
 
-  override unwrap(): S {
+  unwrap(): never {
     this.onUnwrap(this)
     throw this.error
   }
 
-  override unwrapOr<T>(fallback: T): S | T {
+  unwrapOr<T>(fallback: T): T {
     return fallback
   }
-
-  cast<S2 = never>(): DisposableFail<S2, F> {
-    return this as unknown as DisposableFail<S2, F>
-  }
 }
 
-export type DisposableResult<S, F> = DisposableSuccess<S, F> | DisposableFail<S, F>
+export type DisposableResult<S, F> = DisposableSuccess<S> | DisposableFail<F>
 export const DisposableResult = AbstractDisposableResult