}
}
+// stringVal copies string x to Javascript and returns a ref.
+//
+// (noescape): This is safe because no references are maintained to the
+// Go string x after the syscall returns.
+//
//go:wasmimport gojs syscall/js.stringVal
+//go:noescape
func stringVal(x string) ref
// Type represents the JavaScript type of a Value.
return r
}
+// valueGet returns a ref to JavaScript property p of ref v.
+//
+// (noescape): This is safe because no references are maintained to the
+// Go string p after the syscall returns.
+//
//go:wasmimport gojs syscall/js.valueGet
+//go:noescape
func valueGet(v ref, p string) ref
// Set sets the JavaScript property p of value v to ValueOf(x).
runtime.KeepAlive(xv)
}
+// valueSet sets property p of ref v to ref x.
+//
+// (noescape): This is safe because no references are maintained to the
+// Go string p after the syscall returns.
+//
//go:wasmimport gojs syscall/js.valueSet
+//go:noescape
func valueSet(v ref, p string, x ref)
// Delete deletes the JavaScript property p of value v.
runtime.KeepAlive(v)
}
+// valueDelete deletes the JavaScript property p of ref v.
+//
+// (noescape): This is safe because no references are maintained to the
+// Go string p after the syscall returns.
+//
//go:wasmimport gojs syscall/js.valueDelete
+//go:noescape
func valueDelete(v ref, p string)
// Index returns JavaScript index i of value v.
//go:wasmimport gojs syscall/js.valueSetIndex
func valueSetIndex(v ref, i int, x ref)
-func makeArgs(args []any) ([]Value, []ref) {
- argVals := make([]Value, len(args))
- argRefs := make([]ref, len(args))
+// makeArgSlices makes two slices to hold JavaScript arg data.
+// It can be paired with storeArgs to make-and-store JavaScript arg slices.
+// However, the two functions are separated to ensure makeArgSlices is inlined
+// which will prevent the slices from being heap allocated for small (<=16)
+// numbers of args.
+func makeArgSlices(size int) (argVals []Value, argRefs []ref) {
+ // value chosen for being power of two, and enough to handle all web APIs
+ // in particular, note that WebGL2's texImage2D takes up to 10 arguments
+ const maxStackArgs = 16
+ if size <= maxStackArgs {
+ // as long as makeArgs is inlined, these will be stack-allocated
+ argVals = make([]Value, size, maxStackArgs)
+ argRefs = make([]ref, size, maxStackArgs)
+ } else {
+ // allocates on the heap, but exceeding maxStackArgs should be rare
+ argVals = make([]Value, size)
+ argRefs = make([]ref, size)
+ }
+ return
+}
+
+// storeArgs maps input args onto respective Value and ref slices.
+// It can be paired with makeArgSlices to make-and-store JavaScript arg slices.
+func storeArgs(args []any, argValsDst []Value, argRefsDst []ref) {
+ // would go in makeArgs if the combined func was simple enough to inline
for i, arg := range args {
v := ValueOf(arg)
- argVals[i] = v
- argRefs[i] = v.ref
+ argValsDst[i] = v
+ argRefsDst[i] = v.ref
}
- return argVals, argRefs
}
// Length returns the JavaScript property "length" of v.
// It panics if v has no method m.
// The arguments get mapped to JavaScript values according to the ValueOf function.
func (v Value) Call(m string, args ...any) Value {
- argVals, argRefs := makeArgs(args)
+ argVals, argRefs := makeArgSlices(len(args))
+ storeArgs(args, argVals, argRefs)
res, ok := valueCall(v.ref, m, argRefs)
runtime.KeepAlive(v)
runtime.KeepAlive(argVals)
return makeValue(res)
}
+// valueCall does a JavaScript call to the method name m of ref v with the given arguments.
+//
+// (noescape): This is safe because no references are maintained to the
+// Go string m after the syscall returns. Additionally, the args slice
+// is only used temporarily to collect the JavaScript objects for
+// the JavaScript method invocation.
+//
//go:wasmimport gojs syscall/js.valueCall
//go:nosplit
+//go:noescape
func valueCall(v ref, m string, args []ref) (ref, bool)
// Invoke does a JavaScript call of the value v with the given arguments.
// It panics if v is not a JavaScript function.
// The arguments get mapped to JavaScript values according to the ValueOf function.
func (v Value) Invoke(args ...any) Value {
- argVals, argRefs := makeArgs(args)
+ argVals, argRefs := makeArgSlices(len(args))
+ storeArgs(args, argVals, argRefs)
res, ok := valueInvoke(v.ref, argRefs)
runtime.KeepAlive(v)
runtime.KeepAlive(argVals)
return makeValue(res)
}
+// valueInvoke does a JavaScript call to value v with the given arguments.
+//
+// (noescape): This is safe because the args slice is only used temporarily
+// to collect the JavaScript objects for the JavaScript method
+// invocation.
+//
//go:wasmimport gojs syscall/js.valueInvoke
+//go:noescape
func valueInvoke(v ref, args []ref) (ref, bool)
// New uses JavaScript's "new" operator with value v as constructor and the given arguments.
// It panics if v is not a JavaScript function.
// The arguments get mapped to JavaScript values according to the ValueOf function.
func (v Value) New(args ...any) Value {
- argVals, argRefs := makeArgs(args)
+ argVals, argRefs := makeArgSlices(len(args))
+ storeArgs(args, argVals, argRefs)
res, ok := valueNew(v.ref, argRefs)
runtime.KeepAlive(v)
runtime.KeepAlive(argVals)
return makeValue(res)
}
+// valueNew uses JavaScript's "new" operator with value v as a constructor and the given arguments.
+//
+// (noescape): This is safe because the args slice is only used temporarily
+// to collect the JavaScript objects for the constructor execution.
+//
//go:wasmimport gojs syscall/js.valueNew
+//go:noescape
func valueNew(v ref, args []ref) (ref, bool)
func (v Value) isNumber() bool {
//go:wasmimport gojs syscall/js.valuePrepareString
func valuePrepareString(v ref) (ref, int)
+// valueLoadString loads string data located at ref v into byte slice b.
+//
+// (noescape): This is safe because the byte slice is only used as a destination
+// for storing the string data and references to it are not maintained.
+//
//go:wasmimport gojs syscall/js.valueLoadString
+//go:noescape
func valueLoadString(v ref, b []byte)
// InstanceOf reports whether v is an instance of type t according to JavaScript's instanceof operator.
return n
}
+// copyBytesToGo copies bytes from src to dst.
+//
+// (noescape): This is safe because the dst byte slice is only used as a dst
+// copy buffer and no references to it are maintained.
+//
//go:wasmimport gojs syscall/js.copyBytesToGo
+//go:noescape
func copyBytesToGo(dst []byte, src ref) (int, bool)
// CopyBytesToJS copies bytes from src to dst.
return n
}
+// copyBytesToJs copies bytes from src to dst.
+//
+// (noescape): This is safe because the src byte slice is only used as a src
+// copy buffer and no references to it are maintained.
+//
//go:wasmimport gojs syscall/js.copyBytesToJS
+//go:noescape
func copyBytesToJS(dst ref, src []byte) (int, bool)
}
}
+// This table is used for allocation tests. We expect a specific allocation
+// behavior to be seen, depending on the number of arguments applied to various
+// JavaScript functions.
+// Note: All JavaScript functions return a JavaScript array, which will cause
+// one allocation to be created to track the Value.gcPtr for the Value finalizer.
+var allocTests = []struct {
+ argLen int // The number of arguments to use for the syscall
+ expected int // The expected number of allocations
+}{
+ // For less than or equal to 16 arguments, we expect 1 alloction:
+ // - makeValue new(ref)
+ {0, 1},
+ {2, 1},
+ {15, 1},
+ {16, 1},
+ // For greater than 16 arguments, we expect 3 alloction:
+ // - makeValue: new(ref)
+ // - makeArgSlices: argVals = make([]Value, size)
+ // - makeArgSlices: argRefs = make([]ref, size)
+ {17, 3},
+ {32, 3},
+ {42, 3},
+}
+
+// TestCallAllocations ensures the correct allocation profile for Value.Call
+func TestCallAllocations(t *testing.T) {
+ for _, test := range allocTests {
+ args := make([]any, test.argLen)
+
+ tmpArray := js.Global().Get("Array").New(0)
+ numAllocs := testing.AllocsPerRun(100, func() {
+ tmpArray.Call("concat", args...)
+ });
+
+ if numAllocs != float64(test.expected) {
+ t.Errorf("got numAllocs %#v, want %#v", numAllocs, test.expected)
+ }
+ }
+}
+
+// TestInvokeAllocations ensures the correct allocation profile for Value.Invoke
+func TestInvokeAllocations(t *testing.T) {
+ for _, test := range allocTests {
+ args := make([]any, test.argLen)
+
+ tmpArray := js.Global().Get("Array").New(0)
+ concatFunc := tmpArray.Get("concat").Call("bind", tmpArray)
+ numAllocs := testing.AllocsPerRun(100, func() {
+ concatFunc.Invoke(args...)
+ });
+
+ if numAllocs != float64(test.expected) {
+ t.Errorf("got numAllocs %#v, want %#v", numAllocs, test.expected)
+ }
+ }
+}
+
+// TestNewAllocations ensures the correct allocation profile for Value.New
+func TestNewAllocations(t *testing.T) {
+ arrayConstructor := js.Global().Get("Array")
+
+ for _, test := range allocTests {
+ args := make([]any, test.argLen)
+
+ numAllocs := testing.AllocsPerRun(100, func() {
+ arrayConstructor.New(args...)
+ });
+
+ if numAllocs != float64(test.expected) {
+ t.Errorf("got numAllocs %#v, want %#v", numAllocs, test.expected)
+ }
+ }
+}
+
// BenchmarkDOM is a simple benchmark which emulates a webapp making DOM operations.
// It creates a div, and sets its id. Then searches by that id and sets some data.
// Finally it removes that div.