Add the ThrowException fn to the isolate

CHANGELOG.md

@@ -16,6 +16,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Support for setting and getting internal fields for template object instances
 - Support for CPU profiling
 - Add V8 build for Apple Silicon
+- Add support for throwing an exception directly via the isolate's ThrowException function.
 
 ### Changed
 - Removed error return value from NewIsolate which never fails

isolate.go

@@ -103,6 +103,19 @@ func (i *Isolate) Dispose() {
  i.ptr = nil
 }
 
+// ThrowException schedules an exception to be thrown when returning to
+// JavaScript. When an exception has been scheduled it is illegal to invoke
+// any JavaScript operation; the caller must return immediately and only after
+// the exception has been handled does it become legal to invoke JavaScript operations.
+func (i *Isolate) ThrowException(value *Value) *Value {
+ if i.ptr == nil {
+ panic("Isolate has been disposed")
+ }
+ return &Value{
+ ptr: C.IsolateThrowException(i.ptr, value.ptr),
+ }
+}
+
 // Deprecated: use `iso.Dispose()`.
 func (i *Isolate) Close() {
  i.Dispose()

isolate_test.go

@@ -136,6 +136,58 @@ func TestIsolateGarbageCollection(t *testing.T) {
  time.Sleep(time.Second)
 }
 
+func TestIsolateThrowException(t *testing.T) {
+ t.Parallel()
+ iso := v8.NewIsolate()
+ defer iso.Dispose()
+
+ strErr, _ := v8.NewValue(iso, "some type error")
+
+ throwError := func(val *v8.Value) {
+ v := iso.ThrowException(val)
+
+ if !v.IsNullOrUndefined() {
+ t.Error("expected result to be null or undefined")
+ }
+ }
+
+ // Function that throws a simple string error from within the function. It is meant
+ // to emulate when an error is returned within Go.
+ fn := v8.NewFunctionTemplate(iso, func(info *v8.FunctionCallbackInfo) *v8.Value {
+ throwError(strErr)
+
+ return nil
+ })
+
+ // Function that is passed a TypeError from JavaScript.
+ fn2 := v8.NewFunctionTemplate(iso, func(info *v8.FunctionCallbackInfo) *v8.Value {
+ typeErr := info.Args()[0]
+
+ throwError(typeErr)
+
+ return nil
+ })
+
+ global := v8.NewObjectTemplate(iso)
+ global.Set("foo", fn)
+ global.Set("foo2", fn2)
+
+ ctx := v8.NewContext(iso, global)
+ defer ctx.Close()
+
+ _, e := ctx.RunScript("foo()", "foo.js")
+
+ if e.Error() != "some type error" {
+ t.Errorf("expected \"some type error\" error but got: %v", e)
+ }
+
+ _, e = ctx.RunScript("foo2(new TypeError('this is a test'))", "foo.js")
+
+ if e.Error() != "TypeError: this is a test" {
+ t.Errorf("expected \"TypeError: this is a test\" error but got: %v", e)
+ }
+}
+
 func BenchmarkIsolateInitialization(b *testing.B) {
  b.ReportAllocs()
  for n := 0; n < b.N; n++ {

v8go.cc

@@ -198,6 +198,23 @@ IsolateHStatistics IsolationGetHeapStatistics(IsolatePtr iso) {
  hs.number_of_detached_contexts()};
 }
 
+/********** Exceptions & Errors **********/
+
+ValuePtr IsolateThrowException(IsolatePtr iso, ValuePtr value) {
+ ISOLATE_SCOPE(iso);
+ m_ctx* ctx = value->ctx;
+
+ Local<Value> throw_ret_val = iso->ThrowException(value->ptr.Get(iso));
+
+ m_value* new_val = new m_value;
+ new_val->iso = iso;
+ new_val->ctx = ctx;
+ new_val->ptr = Persistent<Value, CopyablePersistentTraits<Value>>(
+ iso, throw_ret_val);
+
+ return tracked_value(ctx, new_val);
+}
+
 /********** CpuProfiler **********/
 
 CPUProfiler* NewCPUProfiler(IsolatePtr iso_ptr) {

v8go.h

@@ -114,6 +114,8 @@ extern void IsolateTerminateExecution(IsolatePtr ptr);
 extern int IsolateIsExecutionTerminating(IsolatePtr ptr);
 extern IsolateHStatistics IsolationGetHeapStatistics(IsolatePtr ptr);
 
+extern ValuePtr IsolateThrowException(IsolatePtr iso, ValuePtr value);
+
 extern CPUProfiler* NewCPUProfiler(IsolatePtr iso_ptr);
 extern void CPUProfilerDispose(CPUProfiler* ptr);
 extern void CPUProfilerStartProfiling(CPUProfiler* ptr, const char* title);