Propsed fix for struct and array vals in interface-typed variables

myitcv · myitcv · commit da2f54948092 · 2017-08-01T09:43:12.000+01:00
diff --git a/circle.yml b/circle.yml
@@ -18,7 +18,7 @@ test:
     - go tool vet *.go                                                   # Go package in root directory.
     - for d in */; do echo $d; done | grep -v tests/ | grep -v third_party/ | xargs go tool vet # All subdirectories except "tests", "third_party".
     - >
-      gopherjs test --short --minify
+      gopherjs test --minify
       github.com/gopherjs/gopherjs/tests
       github.com/gopherjs/gopherjs/tests/main
       github.com/gopherjs/gopherjs/js
diff --git a/compiler/expressions.go b/compiler/expressions.go
@@ -1113,7 +1113,12 @@ func (c *funcContext) translateImplicitConversion(expr ast.Expr, desiredType typ
 
 	exprType := c.p.TypeOf(expr)
 	if types.Identical(exprType, desiredType) {
-		return c.translateExpr(expr)
+		switch exprType.Underlying().(type) {
+		case *types.Interface:
+			return c.formatExpr("$copyIntf(%e)", expr)
+		default:
+			return c.translateExpr(expr)
+		}
 	}
 
 	basicExprType, isBasicExpr := exprType.Underlying().(*types.Basic)
@@ -1130,11 +1135,14 @@ func (c *funcContext) translateImplicitConversion(expr ast.Expr, desiredType typ
 			// wrap JS object into js.Object struct when converting to interface
 			return c.formatExpr("new $jsObjectPtr(%e)", expr)
 		}
+		if _, isArray := exprType.Underlying().(*types.Array); isArray {
+			return c.formatExpr("new %1s($clone(%e, %1s))", c.typeName(exprType), expr)
+		}
 		if isWrapped(exprType) {
 			return c.formatExpr("new %s(%e)", c.typeName(exprType), expr)
 		}
 		if _, isStruct := exprType.Underlying().(*types.Struct); isStruct {
-			return c.formatExpr("new %1e.constructor.elem(%1e)", expr)
+			return c.formatExpr("new %1e.constructor.elem($clone(%1e, %s))", expr, c.typeName(exprType))
 		}
 	}
 
diff --git a/compiler/prelude/prelude.go b/compiler/prelude/prelude.go
@@ -293,6 +293,14 @@ var $clone = function(src, type) {
   return clone;
 };
 
+var $copyIntf = function(src) {
+	if (src.constructor.copy) {
+		return new src.constructor($clone(src.$val, src.constructor));
+	}
+
+	return src;
+};
+
 var $pointerOfStructConversion = function(obj, type) {
   if(obj.$proxies === undefined) {
     obj.$proxies = {};
diff --git a/tests/interface_test.go b/tests/interface_test.go
@@ -0,0 +1,88 @@
+package tests
+
+import (
+	"fmt"
+	"testing"
+)
+
+type Struct struct {
+	Name string
+}
+
+func (s Struct) SetName(n string) {
+	s.Name = n
+}
+
+type SetName interface {
+	SetName(n string)
+}
+
+func TestAssignStructValInterface(t *testing.T) {
+	s := Struct{
+		Name: "Rob",
+	}
+
+	var i1 interface{} = s
+	var i2 interface{} = i1
+
+	s.Name = "Pike"
+
+	ss := fmt.Sprintf("%#v", s)
+	i1s := fmt.Sprintf("%#v", i1)
+	i2s := fmt.Sprintf("%#v", i2)
+
+	if exp := "tests.Struct{Name:\"Pike\"}"; ss != exp {
+		t.Fatalf("ss should have been %q; got %q", exp, ss)
+	}
+
+	iexp := "tests.Struct{Name:\"Rob\"}"
+
+	if i1s != iexp {
+		t.Fatalf("is should have been %q; got %q", iexp, i1s)
+	}
+
+	if i2s != iexp {
+		t.Fatalf("is should have been %q; got %q", iexp, i2s)
+	}
+}
+
+func TestStructValIntfMethodCall(t *testing.T) {
+	var i SetName = Struct{
+		Name: "Rob",
+	}
+
+	i.SetName("Pike")
+
+	is := fmt.Sprintf("%#v", i)
+
+	if exp := "tests.Struct{Name:\"Rob\"}"; is != exp {
+		t.Fatalf("is should have been %q; got %q", exp, is)
+	}
+}
+
+func TestAssignArrayInterface(t *testing.T) {
+	a := [2]int{1, 2}
+
+	var i1 interface{} = a
+	var i2 interface{} = i1
+
+	a[0] = 0
+
+	as := fmt.Sprintf("%#v", a)
+	i1s := fmt.Sprintf("%#v", i1)
+	i2s := fmt.Sprintf("%#v", i2)
+
+	if exp := "[2]int{0, 2}"; as != exp {
+		t.Fatalf("ss should have been %q; got %q", exp, as)
+	}
+
+	iexp := "[2]int{1, 2}"
+
+	if i1s != iexp {
+		t.Fatalf("is should have been %q; got %q", iexp, i1s)
+	}
+
+	if i2s != iexp {
+		t.Fatalf("is should have been %q; got %q", iexp, i2s)
+	}
+}

Original file line number	Diff line number	Diff line change
`@@ -1113,7 +1113,12 @@ func (c *funcContext) translateImplicitConversion(expr ast.Expr, desiredType typ`
`1113`	`1113`
`1114`	`1114`	`exprType := c.p.TypeOf(expr)`
`1115`	`1115`	`if types.Identical(exprType, desiredType) {`
`1116`		`- return c.translateExpr(expr)`
	`1116`	`+ switch exprType.Underlying().(type) {`
	`1117`	`+ case *types.Interface:`
	`1118`	`+ return c.formatExpr("$copyIntf(%e)", expr)`
	`1119`	`+ default:`
	`1120`	`+ return c.translateExpr(expr)`
	`1121`	`+ }`
`1117`	`1122`	`}`
`1118`	`1123`
`1119`	`1124`	`basicExprType, isBasicExpr := exprType.Underlying().(*types.Basic)`
`@@ -1130,11 +1135,14 @@ func (c *funcContext) translateImplicitConversion(expr ast.Expr, desiredType typ`
`1130`	`1135`	`// wrap JS object into js.Object struct when converting to interface`
`1131`	`1136`	`return c.formatExpr("new $jsObjectPtr(%e)", expr)`
`1132`	`1137`	`}`
	`1138`	`+ if _, isArray := exprType.Underlying().(*types.Array); isArray {`
	`1139`	`+ return c.formatExpr("new %1s($clone(%e, %1s))", c.typeName(exprType), expr)`
	`1140`	`+ }`
`1133`	`1141`	`if isWrapped(exprType) {`
`1134`	`1142`	`return c.formatExpr("new %s(%e)", c.typeName(exprType), expr)`
`1135`	`1143`	`}`
`1136`	`1144`	`if _, isStruct := exprType.Underlying().(*types.Struct); isStruct {`
`1137`		`- return c.formatExpr("new %1e.constructor.elem(%1e)", expr)`
	`1145`	`+ return c.formatExpr("new %1e.constructor.elem($clone(%1e, %s))", expr, c.typeName(exprType))`
`1138`	`1146`	`}`
`1139`	`1147`	`}`
`1140`	`1148`