Merge pull request #838 from thefrontside/scope-run-link

If an uncaught error happens in Scope.run(), crash the scope.

lib/run/frame.ts

@@ -122,6 +122,8 @@ export function createFrame<T>(options: FrameOptions<T>): Frame<T> {
       thunk = thunks.pop()!;
     }
 
+    frame.exited = true;
+
     let result = thunk.value;
 
     let exit: Exit<T>;

lib/run/scope.ts

@@ -1,4 +1,5 @@
 import type { Context, Frame, Future, Operation, Scope } from "../types.ts";
+import { evaluate } from "../deps.ts";
 import { create } from "./create.ts";
 import { createFrame } from "./frame.ts";
 import { getframe, suspend } from "../instructions.ts";
@@ -40,8 +41,24 @@ export function createScope(frame?: Frame): [Scope, () => Future<void>] {
 
   let scope = create<Scope>("Scope", {}, {
     run<T>(operation: () => Operation<T>) {
+      if (parent.exited) {
+        let error = new Error(
+          `cannot call run() on a scope that has already been exited`,
+        );
+        error.name = "InactiveScopeError";
+        throw error;
+      }
+
       let frame = parent.createChild(operation);
       frame.enter();
+
+      evaluate(function* () {
+        let result = yield* frame;
+        if (!result.ok) {
+          yield* parent.crash(result.error);
+        }
+      });
+
       return frame.getTask();
     },
     get<T>(context: Context<T>) {

lib/types.ts

@@ -298,6 +298,7 @@ import type { FrameResult } from "./run/types.ts";
 export interface Frame<T = unknown> extends Computation<FrameResult<T>> {
   id: number;
   context: Record<string, unknown>;
+  exited?: true;
   aborted?: boolean;
   getTask(): Task<T>;
   createChild<C>(operation: () => Operation<C>): Frame<C>;

test/scope.test.ts

@@ -58,7 +58,7 @@ describe("Scope", () => {
     scope.run(function* () {
       throw error;
     });
-    await expect(close()).resolves.toEqual(void 0);
+    await expect(close()).resolves.toBeUndefined();
     expect(tester.status).toEqual("closed");
   });
 
@@ -106,6 +106,24 @@ describe("Scope", () => {
     expect(scope.get(context)).toEqual("Hello World!");
     await expect(scope.run(() => context)).resolves.toEqual("Hello World!");
   });
+
+  it("propagates uncaught errors within a scope", async () => {
+    let error = new Error("boom");
+    let result = run(function* () {
+      let scope = yield* useScope();
+      scope.run(function* () {
+        throw error;
+      });
+      yield* suspend();
+    });
+    await expect(result).rejects.toBe(error);
+  });
+
+  it("throws an error if you try to run() with a dead scope", async () => {
+    let scope = await run(useScope);
+
+    expect(() => scope.run(function* () {})).toThrow("cannot call");
+  });
 });
 
 interface Tester {