Support for invoking a function value (#100)

* Support for invoking a function value

Fixes #95

* *Value -> Valuer, avoid multiple branches of FunctionCall

* Make Call variadic, add a Changelog note

Co-authored-by: Roger Chapman <[email protected]>

CHANGELOG.md

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 - Promise resolver and promise result
+- Convert a Value to a Function and invoke it
 
 ### Changed
 - Upgrade to V8 8.9.255.20

function.go

@@ -0,0 +1,30 @@
+// Copyright 2021 Roger Chapman and the v8go contributors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package v8go
+
+// #include "v8go.h"
+import "C"
+import (
+	"unsafe"
+)
+
+// Function is a JavaScript function.
+type Function struct {
+	*Value
+}
+
+// Call this JavaScript function with the given arguments.
+func (fn *Function) Call(args ...Valuer) (*Value, error) {
+	var argptr *C.ValuePtr
+	if len(args) > 0 {
+		var cArgs = make([]C.ValuePtr, len(args))
+		for i, arg := range args {
+			cArgs[i] = arg.value().ptr
+		}
+		argptr = (*C.ValuePtr)(unsafe.Pointer(&cArgs[0]))
+	}
+	rtn := C.FunctionCall(fn.ptr, C.int(len(args)), argptr)
+	return getValue(fn.ctx, rtn), getError(rtn)
+}

function_test.go

@@ -0,0 +1,63 @@
+// Copyright 2021 Roger Chapman and the v8go contributors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package v8go_test
+
+import (
+	"testing"
+
+	"rogchap.com/v8go"
+)
+
+func TestFunctionCall(t *testing.T) {
+	t.Parallel()
+
+	ctx, err := v8go.NewContext()
+	failIf(t, err)
+	_, err = ctx.RunScript("function add(a, b) { return a + b; }", "")
+	failIf(t, err)
+	addValue, err := ctx.Global().Get("add")
+	failIf(t, err)
+	iso, _ := ctx.Isolate()
+
+	arg1, err := v8go.NewValue(iso, int32(1))
+	failIf(t, err)
+
+	fn, _ := addValue.AsFunction()
+	resultValue, err := fn.Call(arg1, arg1)
+	failIf(t, err)
+
+	if resultValue.Int32() != 2 {
+		t.Errorf("expected 1 + 1 = 2, got: %v", resultValue.DetailString())
+	}
+}
+
+func TestFunctionCallError(t *testing.T) {
+	t.Parallel()
+
+	ctx, err := v8go.NewContext()
+	failIf(t, err)
+	_, err = ctx.RunScript("function throws() { throw 'error'; }", "script.js")
+	failIf(t, err)
+	addValue, err := ctx.Global().Get("throws")
+	failIf(t, err)
+
+	fn, _ := addValue.AsFunction()
+	_, err = fn.Call()
+	if err == nil {
+		t.Errorf("expected an error, got none")
+	}
+	got := *(err.(*v8go.JSError))
+	want := v8go.JSError{Message: "error", Location: "script.js:1:21"}
+	if got != want {
+		t.Errorf("want %+v, got: %+v", want, got)
+	}
+}
+
+func failIf(t *testing.T, err error) {
+	t.Helper()
+	if err != nil {
+		t.Fatal(err)
+	}
+}

v8go.cc

@@ -1084,6 +1084,31 @@ ValuePtr PromiseResult(ValuePtr ptr) {
   return tracked_value(ctx, result_val);
 }
 
+/********** Function **********/
+
+RtnValue FunctionCall(ValuePtr ptr, int argc, ValuePtr args[]) {
+  LOCAL_VALUE(ptr)
+  RtnValue rtn = {nullptr, nullptr};
+  Local<Function> fn = Local<Function>::Cast(value);
+  Local<Value> argv[argc];
+  for (int i = 0; i < argc; i++) {
+    m_value* arg = static_cast<m_value*>(args[i]);
+    argv[i] = arg->ptr.Get(iso);
+  }
+  Local<Value> recv = Undefined(iso);
+  MaybeLocal<Value> result = fn->Call(local_ctx, recv, argc, argv);
+  if (result.IsEmpty()) {
+    rtn.error = ExceptionError(try_catch, iso, local_ctx);
+    return rtn;
+  }
+  m_value* rtnval = new m_value;
+  rtnval->iso = iso;
+  rtnval->ctx = ctx;
+  rtnval->ptr = Persistent<Value, CopyablePersistentTraits<Value>>(iso, result.ToLocalChecked());
+  rtn.value = tracked_value(ctx, rtnval);
+  return rtn;
+}
+
 /******** Exceptions *********/
 
 ValuePtr ExceptionError(IsolatePtr iso_ptr, const char* message) {

v8go.h

@@ -173,6 +173,8 @@ int PromiseResolverReject(ValuePtr ptr, ValuePtr val_ptr);
 int PromiseState(ValuePtr ptr);
 extern ValuePtr PromiseResult(ValuePtr ptr);
 
+extern RtnValue FunctionCall(ValuePtr ptr, int argc, ValuePtr argv[]);
+
 extern ValuePtr ExceptionError(IsolatePtr iso_ptr, const char* message);
 extern ValuePtr ExceptionRangeError(IsolatePtr iso_ptr, const char* message);
 extern ValuePtr ExceptionReferenceError(IsolatePtr iso_ptr,

value.go

@@ -528,6 +528,13 @@ func (v *Value) AsPromise() (*Promise, error) {
 	return &Promise{&Object{v}}, nil
 }
 
+func (v *Value) AsFunction() (*Function, error) {
+	if !v.IsFunction() {
+		return nil, errors.New("v8go: value is not a Function")
+	}
+	return &Function{v}, nil
+}
+
 // MarshalJSON implements the json.Marshaler interface.
 func (v *Value) MarshalJSON() ([]byte, error) {
 	jsonStr, err := JSONStringify(nil, v)

value_test.go

@@ -395,6 +395,24 @@ func TestValuePromise(t *testing.T) {
 
 }
 
+func TestValueFunction(t *testing.T) {
+	t.Parallel()
+
+	ctx, _ := v8go.NewContext()
+	val, _ := ctx.RunScript("1", "")
+	if _, err := val.AsFunction(); err == nil {
+		t.Error("Expected error but got <nil>")
+	}
+	val, err := ctx.RunScript("(a, b) => { return a + b; }", "")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if _, err := val.AsFunction(); err != nil {
+		t.Errorf("Expected success but got: %v", err)
+	}
+
+}
+
 func TestValueIsXXX(t *testing.T) {
 	t.Parallel()
 	iso, _ := v8go.NewIsolate()