New Mojom parser: Fix serialization of arrays and maps.

mojom/mojom_parser/serialization/serialization.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package serialization
 
 import (
         "fmt"
         "mojo/public/go/bindings"
         "mojom/mojom_parser/generated/mojom_files"
@@ skipping 290 matching lines @@
 
 func translateTypeRef(typeRef mojom.TypeRef) mojom_types.Type {
         switch t := typeRef.(type) {
         case mojom.SimpleType:
                 return translateSimpleType(t)
         case mojom.StringType:
                 return translateStringType(t)
         case mojom.HandleTypeRef:
                 return translateHandleType(t)
         case mojom.ArrayTypeRef:
+                return translateArrayType(&t)
+        case *mojom.ArrayTypeRef:
                 return translateArrayType(t)
         case mojom.MapTypeRef:
+                return translateMapType(&t)
+        case *mojom.MapTypeRef:
                 return translateMapType(t)
         case *mojom.UserTypeRef:
                 return translateUserTypeRef(t)
         default:
                 panic(fmt.Sprintf("Unexpected TypeRef type %T", t))
         }
 }
 
 func translateSimpleType(simpleType mojom.SimpleType) *mojom_types.TypeSimpleType {
         var value mojom_types.SimpleType
@@ skipping 38 matching lines @@
         case mojom.HandleKindDataPipeConsumer:
                 kind = mojom_types.HandleType_Kind_DataPipeConsumer
         case mojom.HandleKindDataPipeProducer:
                 kind = mojom_types.HandleType_Kind_DataPipeProducer
         case mojom.HandleKindSharedBuffer:
                 kind = mojom_types.HandleType_Kind_SharedBuffer
         }
         return &mojom_types.TypeHandleType{mojom_types.HandleType{handleType.Nullable(), kind}}
 }
 
-func translateArrayType(arrayType mojom.ArrayTypeRef) *mojom_types.TypeArrayType {
+func translateArrayType(arrayType *mojom.ArrayTypeRef) *mojom_types.TypeArrayType {
         return &mojom_types.TypeArrayType{mojom_types.ArrayType{
                 Nullable:    arrayType.Nullable(),
                 FixedLength: int32(arrayType.FixedLength()),
                 ElementType: translateTypeRef(arrayType.ElementType())}}
 }
 
-func translateMapType(mapType mojom.MapTypeRef) *mojom_types.TypeMapType {
+func translateMapType(mapType *mojom.MapTypeRef) *mojom_types.TypeMapType {
         return &mojom_types.TypeMapType{mojom_types.MapType{
                 Nullable:  mapType.Nullable(),
                 KeyType:   translateTypeRef(mapType.KeyType()),
                 ValueType: translateTypeRef(mapType.ValueType())}}
 }
 
 func translateUserTypeRef(userType *mojom.UserTypeRef) *mojom_types.TypeTypeReference {
         typeKey := stringPointer(userType.ResolvedType().TypeKey())
         identifier := stringPointer(userType.Identifier())
         return &mojom_types.TypeTypeReference{mojom_types.TypeReference{
@@ skipping 165 matching lines @@
 
 // stringPointer is a convenience function for creating a pointer to a string whose value
 // is the specified string. It may be used in situations where the compiler will
 // not allow you to take the address of a string value directly, such as the
 // return value of a function. It is necessary to create pointers to strings because
 // that is how the Mojom type |string?| (i.e. nullable string) is represented in
 // in the Mojom Go bindings.
 func stringPointer(s string) *string {
         return &s
 }