WIP fixes for internalize and zero val translation of undefined and null

myitcv · myitcv · commit 0d5cce035d12 · 2017-04-08T15:52:51.000+01:00
diff --git a/compiler/prelude/jsmapping.go b/compiler/prelude/jsmapping.go
@@ -321,6 +321,12 @@ var $internalize = function(v, t, recv) {
   case $kindSlice:
     return new t($mapArray(v, function(e) { return $internalize(e, t.elem); }));
   case $kindString:
+    if (v === undefined || v == null) {
+      return "";
+    }
+    if (typeof v !== "string") {
+      $throwRuntimeError("tried to internalize non-string value of type " + typeof v);
+    }
     v = String(v);
     if (v.search(/^[\x00-\x7F]*$/) !== -1) {
       return v;
diff --git a/js/js.go b/js/js.go
@@ -58,7 +58,11 @@ func (o *Object) New(args ...interface{}) *Object { return o.object.New(args...)
 // Bool returns the object converted to bool according to JavaScript type conversions.
 func (o *Object) Bool() bool { return o.object.Bool() }
 
-// String returns the object converted to string according to JavaScript type conversions.
+// String returns the underlying Javascript value as a string. If the
+// Javascript type of the underlying value is not string, then a runtime error
+// is thrown.  If you want non-string values to be converted to string values
+// you need to perform that conversion first using js.Global.Call("String",
+// o).String() or similar.
 func (o *Object) String() string { return o.object.String() }
 
 // Int returns the object converted to int according to JavaScript type conversions (parseInt).
diff --git a/js/js_test.go b/js/js_test.go
@@ -571,3 +571,45 @@ func TestUint8Array(t *testing.T) {
 		t.Errorf("Non-empty byte array is not externalized as a Uint8Array")
 	}
 }
+
+func TestInternalizeString(t *testing.T) {
+	type S struct {
+		*js.Object
+
+		string string `js:"string"`
+	}
+
+	s := &S{Object: js.Global.Get("Object").New()}
+
+	zero := ""
+	if v := s.string; v != zero {
+		t.Fatalf("expected string field to be %q, got %q", zero, v)
+	}
+
+	if v := s.Object.Get("string").String(); v != zero {
+		t.Fatalf("expected string field to be %q, got %q", zero, v)
+	}
+
+	s.Object.Set("string", []int{1, 2, 3})
+
+	panicked := false
+
+	func() {
+		defer func() {
+			err := recover().(error)
+			exp := "runtime error: tried to internalize non-string value of type object"
+
+			if err.Error() != exp {
+				t.Fatalf("expected error %q, got %q", exp, err)
+			}
+
+			panicked = true
+		}()
+
+		_ = s.string
+	}()
+
+	if !panicked {
+		t.Fatalf("expected to have had to handle panic; we didn't see a panic")
+	}
+}
