fix(go): map values incorrectly handled though de/serialization (#2587)

Map values were not handled in the de/serialization routines, resulting
in incorrect behavior.



---

By submitting this pull request, I confirm that my contribution is made under the terms of the [Apache 2.0 license].

[Apache 2.0 license]: https://www.apache.org/licenses/LICENSE-2.0

packages/@jsii/go-runtime/jsii-calc-test/main_test.go

@@ -206,3 +206,24 @@ func TestReturnsSpecialParam(t *testing.T) {
 		t.Errorf("Expected type: %s; Actual: %s", expected, actual)
 	}
 }
+
+func TestMaps(t *testing.T) {
+	allTypes := calc.NewAllTypes()
+	actual := allTypes.GetMapProperty()
+	if len(actual) != 0 {
+		t.Errorf("Expected length of empty map to be 0. Got: %d", len(actual))
+	}
+
+	question := "The answer to the ultimate question of life, the universe, and everything"
+	answer := calclib.NewNumber(42)
+	allTypes.SetMapProperty(map[string]calclib.NumberIface{
+		question: answer,
+	})
+	actual = allTypes.GetMapProperty()
+	if len(actual) != 1 {
+		t.Errorf("Expected length of empty map to be 1. Got: %d", len(actual))
+	}
+	if actual[question].GetValue() != answer.GetValue() {
+		t.Errorf("Expected to have the value %v in there, got: %v", answer, actual[question])
+	}
+}

packages/@jsii/go-runtime/jsii-runtime-go/api.go

@@ -93,6 +93,10 @@ type enumRef struct {
 	MemberFQN string `json:"$jsii.enum"`
 }
 
+type wireMap struct {
+	MapData map[string]interface{} `json:"$jsii.map"`
+}
+
 type loadRequest struct {
 	kernelRequester
 
@@ -129,7 +133,7 @@ type createResponse struct {
 type delRequest struct {
 	kernelRequester
 
-	API    string `json:"api"`
+	API    string    `json:"api"`
 	ObjRef objectRef `json:"objref"`
 }
 
@@ -140,8 +144,8 @@ type delResponse struct {
 type getRequest struct {
 	kernelRequester
 
-	API      string `json:"api"`
-	Property string `json:"property"`
+	API      string    `json:"api"`
+	Property string    `json:"property"`
 	ObjRef   objectRef `json:"objref"`
 }
 
@@ -165,7 +169,7 @@ type setRequest struct {
 	API      string      `json:"api"`
 	Property string      `json:"property"`
 	Value    interface{} `json:"value"`
-	ObjRef   objectRef      `json:"objref"`
+	ObjRef   objectRef   `json:"objref"`
 }
 
 type staticSetRequest struct {
@@ -196,7 +200,7 @@ type invokeRequest struct {
 	API       string        `json:"api"`
 	Method    string        `json:"method"`
 	Arguments []interface{} `json:"args"`
-	ObjRef    objectRef        `json:"objref"`
+	ObjRef    objectRef     `json:"objref"`
 }
 
 type invokeResponse struct {
@@ -211,7 +215,7 @@ type beginRequest struct {
 	API       string        `json:"api"`
 	Method    *string       `json:"method"`
 	Arguments []interface{} `json:"args"`
-	ObjRef    objectRef        `json:"objref"`
+	ObjRef    objectRef     `json:"objref"`
 }
 
 type beginResponse struct {

packages/@jsii/go-runtime/jsii-runtime-go/runtime.go

@@ -262,15 +262,14 @@ func castValToRef(data interface{}) (objectRef, bool) {
 	return ref, ok
 }
 
-func castValToEnumRef(data interface{}) (enum enumRef, ok bool) {
-	dataVal := reflect.ValueOf(data)
+func castValToEnumRef(data reflect.Value) (enum enumRef, ok bool) {
 	ok = false
 
-	if dataVal.Kind() == reflect.Map {
-		for _, k := range dataVal.MapKeys() {
+	if data.Kind() == reflect.Map {
+		for _, k := range data.MapKeys() {
 			// Finding values type requires extracting from reflect.Value
 			// otherwise .Kind() returns `interface{}`
-			v := reflect.ValueOf(dataVal.MapIndex(k).Interface())
+			v := reflect.ValueOf(data.MapIndex(k).Interface())
 
 			if k.Kind() == reflect.String && k.String() == "$jsii.enum" && v.Kind() == reflect.String {
 				enum.MemberFQN = v.String()
@@ -283,31 +282,99 @@ func castValToEnumRef(data interface{}) (enum enumRef, ok bool) {
 	return
 }
 
+// castValToMap attempts converting the provided jsii wire value to a
+// go map. This recognizes the "$jsii.map" object and does the necessary
+// recursive value conversion.
+func (c *client) castValToMap(data reflect.Value, mapType reflect.Type) (m reflect.Value, ok bool) {
+	ok = false
+
+	if data.Kind() != reflect.Map || data.Type().Key().Kind() != reflect.String {
+		return
+	}
+
+	if mapType.Kind() == reflect.Map && mapType.Key().Kind() != reflect.String {
+		return
+	}
+	anyType := reflect.TypeOf((*interface{})(nil)).Elem()
+	if mapType == anyType {
+		mapType = reflect.TypeOf((map[string]interface{})(nil))
+	}
+
+	dataIter := data.MapRange()
+	for dataIter.Next() {
+		key := dataIter.Key().String()
+		if key != "$jsii.map" {
+			continue
+		}
+
+		// Finding value type requries extracting from reflect.Value
+		// otherwise .Kind() returns `interface{}`
+		val := reflect.ValueOf(dataIter.Value().Interface())
+		if val.Kind() != reflect.Map {
+			return
+		}
+
+		ok = true
+
+		m = reflect.MakeMap(mapType)
+
+		iter := val.MapRange()
+		for iter.Next() {
+			val := iter.Value().Interface()
+			// Note: reflect.New(t) returns a pointer to a newly allocated t
+			convertedVal := reflect.New(mapType.Elem())
+			c.castAndSetToPtr(convertedVal.Interface(), val)
+
+			m.SetMapIndex(iter.Key(), convertedVal.Elem())
+		}
+		return
+	}
+	return
+}
+
 // Accepts pointers to structs that implement interfaces and searches for an
 // existing object reference in the client. If it exists, it casts it to an
 // objref for the runtime. Recursively casts types that may contain nested
 // object references.
 func castPtrToRef(data interface{}) interface{} {
+	if data == nil {
+		return data
+	}
+
 	client := getClient()
 	dataVal := reflect.ValueOf(data)
 
-	if dataVal.Kind() == reflect.Ptr {
+	switch dataVal.Kind() {
+	case reflect.Map:
+		result := wireMap{MapData: make(map[string]interface{})}
+
+		iter := dataVal.MapRange()
+		for iter.Next() {
+			key := iter.Key().String()
+			val := iter.Value().Interface()
+			result.MapData[key] = castPtrToRef(val)
+		}
+
+		return result
+
+	case reflect.Ptr:
 		valref, valHasRef := client.findObjectRef(data)
 		if valHasRef {
 			return objectRef{InstanceID: valref}
 		}
-	} else if dataVal.Kind() == reflect.String {
-		if enumRef, isEnumRef := client.types.tryRenderEnumRef(dataVal); isEnumRef {
-			return enumRef
-		}
-	} else if dataVal.Kind() == reflect.Slice {
+
+	case reflect.Slice:
 		refs := make([]interface{}, dataVal.Len())
 		for i := 0; i < dataVal.Len(); i++ {
 			refs[i] = dataVal.Index(i).Interface()
 		}
 		return refs
-	}
 
+	case reflect.String:
+		if enumRef, isEnumRef := client.types.tryRenderEnumRef(dataVal); isEnumRef {
+			return enumRef
+		}
+	}
 	return data
 }
 
@@ -332,8 +399,8 @@ func (c *client) castAndSetToPtr(ptr interface{}, data interface{}) {
 	ptrVal := reflect.ValueOf(ptr).Elem()
 	dataVal := reflect.ValueOf(data)
 
-	ref, isRef := castValToRef(data)
-	if isRef {
+	// object refs
+	if ref, isRef := castValToRef(data); isRef {
 		// If return data is JSII object references, add to objects table.
 		if concreteType, err := c.types.concreteTypeFor(ptrVal.Type()); err == nil {
 			ptrVal.Set(reflect.New(concreteType))
@@ -344,7 +411,8 @@ func (c *client) castAndSetToPtr(ptr interface{}, data interface{}) {
 		return
 	}
 
-	if enumref, isEnum := castValToEnumRef(data); isEnum {
+	// enums
+	if enumref, isEnum := castValToEnumRef(dataVal); isEnum {
 		member, err := c.types.enumMemberForEnumRef(enumref)
 		if err != nil {
 			panic(err)
@@ -354,6 +422,12 @@ func (c *client) castAndSetToPtr(ptr interface{}, data interface{}) {
 		return
 	}
 
+	// maps
+	if m, isMap := c.castValToMap(dataVal, ptrVal.Type()); isMap {
+		ptrVal.Set(m)
+		return
+	}
+
 	// arrays
 	if ptrVal.Kind() == reflect.Slice && dataVal.Kind() == reflect.Slice {
 		// If return type is a slice, recursively cast elements
@@ -368,8 +442,6 @@ func (c *client) castAndSetToPtr(ptr interface{}, data interface{}) {
 		return
 	}
 
-	// TODO: maps
-
 	if data != nil {
 		val := reflect.ValueOf(data)
 		ptrVal.Set(val)