Catch InterruptedError when calling exported functions (fixes #54)

runtime.go

@@ -1370,6 +1370,15 @@ func AssertFunction(v Value) (Callable, bool) {
 	if obj, ok := v.(*Object); ok {
 		if f, ok := obj.self.assertCallable(); ok {
 			return func(this Value, args ...Value) (ret Value, err error) {
+				defer func() {
+					if x := recover(); x != nil {
+						if ex, ok := x.(*InterruptedError); ok {
+							err = ex
+						} else {
+							panic(x)
+						}
+					}
+				}()
 				ex := obj.runtime.vm.try(func() {
 					ret = f(FunctionCall{
 						This:      this,
@@ -1414,6 +1423,8 @@ func tryFunc(f func()) (err error) {
 			switch x := x.(type) {
 			case *Exception:
 				err = x
+			case *InterruptedError:
+				err = x
 			case Value:
 				err = &Exception{
 					val: x,

runtime_test.go

@@ -1015,6 +1015,35 @@ func TestCreateObject(t *testing.T) {
 	}
 }
 
+func TestInterruptInWrappedFunction(t *testing.T) {
+	rt := New()
+	v, err := rt.RunString(`
+		var fn = function() {
+			while (true) {}
+		};
+		fn;
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fn, ok := AssertFunction(v)
+	if !ok {
+		t.Fatal("Not a function")
+	}
+	go func() {
+		<-time.After(10 * time.Millisecond)
+		rt.Interrupt(errors.New("hi"))
+	}()
+
+	v, err = fn(nil)
+	if err == nil {
+		t.Fatal("expected error")
+	}
+	if _, ok := err.(*InterruptedError); !ok {
+		t.Fatalf("Wrong error type: %T", err)
+	}
+}
+
 /*
 func TestArrayConcatSparse(t *testing.T) {
 function foo(a,b,c)