No way to throw exceptions from native code

[BenLubar]

In a func(otto.FunctionCall) otto.Value, there is no (documented) way to throw a JavaScript exception that the caller can see.

[robertkrimen]

Yes, this is something that needs work. Do you have any examples of what you're trying to achieve?

[cznic]

FWIW, an example, schematically:

js helper

function mkfn(obj, fn) {
        var oldfn = obj[fn];
        obj[fn] = function() {
                var v = oldfn.apply(this, arguments);
                if (v.constructor == Error) {
                        throw v;
                };

                return v;
        };
}

Go errf

func (vm *VM) errf(e error) (r js.Value) {
        if e == nil {
                return js.UndefinedValue()
        }

        r, err := vm.jsvm.Run(fmt.Sprintf("new Error('%s')", template.JSEscapeString(e.Error())))
        if err != nil {
                log.Fatal(err)
        }

        return
}

Example native binding

func (vm *VM) dbArrays(o *js.Object, db *dbm.DB) {
        const (
                obj    = "db"
                method = "arrays"
        )
        if err := o.Set(method, func(call js.FunctionCall) (r js.Value) {
                defer func() {
                        if e := recover(); e != nil {
                                r = vm.errf(fmt.Errorf("%s.%s: %v", obj, method, e))
                        }
                }()

                a, err := db.Arrays()
                if err != nil {
                        panic(err)
                }

                o, err := vm.jsvm.Object(`new Object();`)
                if err != nil {
                        panic(err)
                }

                vm.array(o, &a)
                return o.Value()
        }); err != nil {
                panic(err)
        }

        if _, err := vm.mkfn.Call(js.UndefinedValue(), o, method); err != nil {
                panic(err)
        }
}

Full code: https://github.com/cznic/tmp/blob/14d211b7818be2225f12f80fa299f0176ae771cb/g/glue.go

[robertkrimen]

So what you're trying to do is throw a panic from the inner Go code to the other Go code?

[cznic]

No, the machinery allows the javascript clients to catch errors reported by
Go native functions.
On May 19, 2013 6:56 PM, "Robert Krimen" [email protected] wrote:

So what you're trying to do is initiate a panic from the inner Go code to
the other Go code?

—
Reply to this email directly or view it on GitHubhttps://github.com//issues/17#issuecomment-18120767
.

[robertkrimen]

Yes, I think a Go panic should be visible within a try { ... } catch { ... }, probably as a PanicError, with no extra work necessary.

I also think a (special) piercing panic should be possible, something that can bypass JavaScript.

[cznic]

My example is not about Go panicking. It's about Go errors reporting. The
particular implementation reads data from a disk based database. Read
errors or format corruption may occur. The native funtion needs to throw a
javascript exception in that case - instead of returning, say invalid data
via the javasript wrapped native function - as that cannot support multiple
return values, which Go can.
On May 19, 2013 8:06 PM, "Robert Krimen" [email protected] wrote:

Yes, I think a Go panic should be visible within a try { ... } catch { ...
}, probably as a PanicError, with no extra work necessary.

I also think a (special) piercing panic should be possible, something that
can bypass JavaScript.

—
Reply to this email directly or view it on GitHubhttps://github.com//issues/17#issuecomment-18121942
.

[robertkrimen]

This is partially addressed in e2e79bb

If you panic() something of type otto.Value, then it will behave as if you did a "throw" in JavaScript.

For example: panic(Otto.ToValue("Hello, World.")) is the same as: throw "Hello, World.";

[robertkrimen]

This is further addressed in 83c56dd

I've added a .Call method to Otto, which allows you to call arbitrary JavaScript and return the result.

You can now do something like this in your Go code:

value, _ := call.Otto.Call("new Error", nil, "Something bad happened.")
panic(value)

If you want, a possible convenience function is:

func throw(value Value, _ error) Value {
     panic(value)
     return UndefinedValue()
}

With these two, you can do:

return throw(call.Otto.Call("new Error", nil, "Something bad happened.")

And it'll throw that exception in the JavaScript environment like you would expect

[cznic]

Looks quite good to me. Thanks!

[robertkrimen]

Be careful when doing a raw panic of a complex object:

panic(someObject)
panic(valueOfAnObject)

The above may cause memory issues with the Go runtime, see #59

[BenLubar]

If panic(someObject) uses memory even after recover() is called, that's a Go bug.