Fixing internalization of null slice and array fields

grantnelson-wf · grantnelson-wf · commit 5b667072330f · 2024-05-01T12:43:21.000-06:00
diff --git a/compiler/prelude/jsmapping.js b/compiler/prelude/jsmapping.js
@@ -236,6 +236,9 @@ var $internalize = (v, t, recv, seen, makeWrapper) => {
         case $kindFloat64:
             return parseFloat(v);
         case $kindArray:
+            if (v == null) {
+                return t.zero();
+            }
             if (v.length !== t.len) {
                 $throwRuntimeError("got array with wrong size from JavaScript native");
             }
@@ -331,6 +334,9 @@ var $internalize = (v, t, recv, seen, makeWrapper) => {
                 return $internalize(v, t.elem, makeWrapper);
             }
         case $kindSlice:
+            if (v == null) {
+                return t.zero();
+            }
             return new t($mapArray(v, e => { return $internalize(e, t.elem, makeWrapper); }));
         case $kindString:
             v = String(v);
diff --git a/tests/js_test.go b/tests/js_test.go
@@ -829,6 +829,90 @@ func TestExternalize(t *testing.T) {
 	}
 }
 
+func TestInternalizeSlice(t *testing.T) {
+	tests := []struct {
+		name string
+		init []int
+		want string
+	}{
+		{
+			name: `nil slice`,
+			init: []int(nil),
+			want: `[]int(nil)`,
+		},
+		{
+			name: `empty slice`,
+			init: []int{},
+			want: `[]int{}`,
+		},
+		{
+			name: `non-empty slice`,
+			init: []int{42, 53, 64},
+			want: `[]int{42, 53, 64}`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			b := struct {
+				*js.Object
+				V []int `js:"V"` // V is externalized
+			}{Object: js.Global.Get("Object").New()}
+			b.V = tt.init
+
+			result := fmt.Sprintf(`%#v`, b.V) // internalize b.V
+			if result != tt.want {
+				t.Errorf(`Unexpected result %q != %q`, result, tt.want)
+			}
+		})
+	}
+}
+
+func TestInternalizeArray(t *testing.T) {
+	fn := js.Global.Call("eval", "(function(b, v) { b.V = v; })")
+
+	tests := []struct {
+		name string
+		init any
+		want string
+	}{
+		{
+			name: `null array`,
+			init: nil,
+			want: `[3]int{0, 0, 0}`,
+		},
+		{
+			name: `zeros array`,
+			init: [3]int{},
+			want: `[3]int{0, 0, 0}`,
+		},
+		{
+			name: `non-zero array`,
+			init: [3]int{42, 53, 64},
+			want: `[3]int{42, 53, 64}`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			b := struct {
+				*js.Object
+				V [3]int `js:"V"` // V is externalized
+			}{Object: js.Global.Get("Object").New()}
+
+			// Assign the array to b.V using JS because of GopherJS
+			// assignment of externalized array's issue,
+			// see https://github.com/gopherjs/gopherjs/issues/1302
+			fn.Invoke(b, tt.init)
+
+			result := fmt.Sprintf(`%#v`, b.V) // internalize b.V
+			if result != tt.want {
+				t.Errorf(`Unexpected result %q != %q`, result, tt.want)
+			}
+		})
+	}
+}
+
 func TestInternalizeExternalizeNull(t *testing.T) {
 	type S struct {
 		*js.Object
