v8.Value becomes manually releaseable

context.go

@@ -81,6 +81,12 @@ func (c *Context) Isolate() *Isolate {
 	return c.iso
 }
 
+func (c *Context) RetainedValueCount() int {
+	ctxMutex.Lock()
+	defer ctxMutex.Unlock()
+	return int(C.ContextRetainedValueCount(c.ptr))
+}
+
 // RunScript executes the source JavaScript; origin (a.k.a. filename) provides a
 // reference for the script and used in the stack trace if there is an error.
 // error will be of type `JSError` if not nil.

function_template.go

@@ -37,6 +37,13 @@ func (i *FunctionCallbackInfo) Args() []*Value {
 	return i.args
 }
 
+func (i *FunctionCallbackInfo) Release() {
+	for _, arg := range i.args {
+		arg.Release()
+	}
+	i.this.Release()
+}
+
 // FunctionTemplate is used to create functions at runtime.
 // There can only be one function created from a FunctionTemplate in a context.
 // The lifetime of the created function is equal to the lifetime of the context.

function_template_test.go

@@ -48,6 +48,44 @@ func TestFunctionTemplate_panic_on_nil_callback(t *testing.T) {
 	defer iso.Dispose()
 	v8.NewFunctionTemplate(iso, nil)
 }
+func TestFunctionTemplate_generates_values(t *testing.T) {
+	t.Parallel()
+
+	iso := v8.NewIsolate()
+	defer iso.Dispose()
+	global := v8.NewObjectTemplate(iso)
+	printfn := v8.NewFunctionTemplate(iso, func(info *v8.FunctionCallbackInfo) *v8.Value {
+		fmt.Printf("%+v\n", info.Args())
+		return nil
+	})
+	global.Set("print", printfn, v8.ReadOnly)
+	ctx := v8.NewContext(iso, global)
+	defer ctx.Close()
+	ctx.RunScript("print('foo', 'bar', 0, 1)", "")
+	if ctx.RetainedValueCount() != 5 {
+		t.Errorf("expected 5 retained values, got: %d", ctx.RetainedValueCount())
+	}
+}
+
+func TestFunctionTemplate_releases_values(t *testing.T) {
+	t.Parallel()
+
+	iso := v8.NewIsolate()
+	defer iso.Dispose()
+	global := v8.NewObjectTemplate(iso)
+	printfn := v8.NewFunctionTemplate(iso, func(info *v8.FunctionCallbackInfo) *v8.Value {
+		defer info.Release()
+		fmt.Printf("%+v\n", info.Args())
+		return nil
+	})
+	global.Set("print", printfn, v8.ReadOnly)
+	ctx := v8.NewContext(iso, global)
+	defer ctx.Close()
+	ctx.RunScript("print('foo', 'bar', 0, 1)", "")
+	if ctx.RetainedValueCount() != 0 {
+		t.Errorf("expected 0 retained values, got: %d", ctx.RetainedValueCount())
+	}
+}
 
 func TestFunctionTemplateGetFunction(t *testing.T) {
 	t.Parallel()

v8go.cc

@@ -12,6 +12,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <unordered_map>
 
 #include "_cgo_export.h"
 
@@ -26,12 +27,14 @@ const int ScriptCompilerEagerCompile = ScriptCompiler::kEagerCompile;
 
 struct m_ctx {
   Isolate* iso;
-  std::vector<m_value*> vals;
+  std::unordered_map<long, m_value*> vals;
   std::vector<m_unboundScript*> unboundScripts;
   Persistent<Context> ptr;
+  long nextValId;
 };
 
 struct m_value {
+  long id;
   Isolate* iso;
   m_ctx* ctx;
   Persistent<Value, CopyablePersistentTraits<Value>> ptr;
@@ -119,7 +122,10 @@ m_value* tracked_value(m_ctx* ctx, m_value* val) {
   // Go <--> C, which would be a significant change, as there are places where
   // we get the context from the value, but if we then need the context to get
   // the value, we would be in a circular bind.
-  ctx->vals.push_back(val);
+  if (val->id == 0) {
+    val->id = ctx->nextValId++;
+    ctx->vals[val->id] = val;
+  }
 
   return val;
 }
@@ -600,16 +606,22 @@ ContextPtr NewContext(IsolatePtr iso,
   return ctx;
 }
 
+int ContextRetainedValueCount(ContextPtr ctx) {
+  return ctx->vals.size();
+}
+
 void ContextFree(ContextPtr ctx) {
   if (ctx == nullptr) {
     return;
   }
   ctx->ptr.Reset();
 
-  for (m_value* val : ctx->vals) {
-    val->ptr.Reset();
-    delete val;
+
+  for(auto& [key, value] : ctx->vals) {
+    value->ptr.Reset();
+    delete value;
   }
+  ctx->vals.clear();
 
   for (m_unboundScript* us : ctx->unboundScripts) {
     us->ptr.Reset();
@@ -761,6 +773,17 @@ const char* JSONStringify(ContextPtr ctx, ValuePtr val) {
   return CopyString(json);
 }
 
+
+void ValueRelease(ValuePtr ptr) {
+  if (ptr == nullptr) {
+    return;
+  }
+
+  ptr->ctx->vals.erase(ptr->id);
+  ptr->ptr.Reset();
+  delete ptr;
+}
+
 ValuePtr ContextGlobal(ContextPtr ctx) {
   LOCAL_CONTEXT(ctx);
   m_value* val = new m_value;

v8go.h

@@ -166,6 +166,7 @@ extern void CPUProfileDelete(CPUProfile* ptr);
 extern ContextPtr NewContext(IsolatePtr iso_ptr,
                              TemplatePtr global_template_ptr,
                              int ref);
+extern int ContextRetainedValueCount(ContextPtr ctx);
 extern void ContextFree(ContextPtr ptr);
 extern RtnValue RunScript(ContextPtr ctx_ptr,
                           const char* source,
@@ -207,6 +208,7 @@ extern RtnValue NewValueBigIntFromWords(IsolatePtr iso_ptr,
                                         int sign_bit,
                                         int word_count,
                                         const uint64_t* words);
+void ValueRelease(ValuePtr ptr);
 extern RtnString ValueToString(ValuePtr ptr);
 const uint32_t* ValueToArrayIndex(ValuePtr ptr);
 int ValueToBoolean(ValuePtr ptr);

value.go

@@ -531,6 +531,11 @@ func (v *Value) IsProxy() bool {
 	return C.ValueIsProxy(v.ptr) != 0
 }
 
+// Release this value.  Using the value after calling this function will result in undefined behavior.
+func (v *Value) Release() {
+	C.ValueRelease(v.ptr)
+}
+
 // IsWasmModuleObject returns true if this value is a `WasmModuleObject`.
 func (v *Value) IsWasmModuleObject() bool {
 	// TODO(rogchap): requires test case