[New go generator] Implement declaring unions.

mojom/generators/go/translator/translator.go

 // Copyright 2016 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 translator
 
 import (
         "fmt"
         "log"
         "sort"
@@ skipping 23 matching lines @@
         tmplFile = new(TmplFile)
         file := t.fileGraph.Files[fileName]
 
         tmplFile.PackageName = fileNameToPackageName(fileName)
 
         tmplFile.Structs = make([]*StructTemplate, len(*file.DeclaredMojomObjects.Structs))
         for i, typeKey := range *file.DeclaredMojomObjects.Structs {
                 tmplFile.Structs[i] = t.translateMojomStruct(typeKey)
         }
 
+        tmplFile.Unions = make([]*UnionTemplate, len(*file.DeclaredMojomObjects.Unions))
+        for i, typeKey := range *file.DeclaredMojomObjects.Unions {
+                tmplFile.Unions[i] = t.translateMojomUnion(typeKey)
+        }
+
         tmplFile.Imports = []Import{
                 Import{PackagePath: "mojo/public/go/bindings", PackageName: "bindings"},
                 Import{PackagePath: "fmt", PackageName: "fmt"},
                 Import{PackagePath: "sort", PackageName: "sort"},
         }
         return tmplFile
 }
 
 func (t *translator) GetUserDefinedType(typeKey string) (mojomType mojom_types.UserDefinedType) {
         return t.fileGraph.ResolvedTypes[typeKey]
 }
 
 func (t *translator) translateMojomStruct(typeKey string) (m *StructTemplate) {
         m = new(StructTemplate)
         u := t.GetUserDefinedType(typeKey)
         s, ok := u.Interface().(mojom_types.MojomStruct)
         if !ok {
-                panic(fmt.Sprintf("%s is not a struct.", userDefinedTypeShortName(u)))
+                log.Panicf("%s is not a struct.", userDefinedTypeShortName(u))
         }
         m.Name = t.goTypeName(typeKey)
         m.PrivateName = privateName(m.Name)
         if s.VersionInfo == nil || len(*s.VersionInfo) == 0 {
                 log.Fatalln(m.Name, "does not have any version_info!")
         }
         curVersion := (*s.VersionInfo)[len(*s.VersionInfo)-1]
         m.CurVersionSize = curVersion.NumBytes
         m.CurVersionNumber = curVersion.VersionNumber
 
@@ skipping 14 matching lines @@
 
 func (t *translator) translateStructField(mojomField *mojom_types.StructField) (field StructFieldTemplate) {
         field.Name = formatName(*mojomField.DeclData.ShortName)
         field.Type = t.translateType(mojomField.Type)
         field.MinVersion = mojomField.MinVersion
         field.EncodingInfo = t.encodingInfo(mojomField.Type)
         field.EncodingInfo.setIdentifier("s." + field.Name)
         return
 }
 
+func (t *translator) translateMojomUnion(typeKey string) (m *UnionTemplate) {
+        m = new(UnionTemplate)
+        u := t.GetUserDefinedType(typeKey)
+        union, ok := u.Interface().(mojom_types.MojomUnion)
+        if !ok {
+                log.Panicf("%s is not a union.\n", userDefinedTypeShortName(u))
+        }
+        m.Name = t.goTypeName(typeKey)
+
+        for _, field := range union.Fields {
+                m.Fields = append(m.Fields, t.translateUnionField(&field))
+                m.Fields[len(m.Fields)-1].Union = m
+        }
+
+        return m
+}
+
+func (t *translator) translateUnionField(mojomField *mojom_types.UnionField) (field UnionFieldTemplate) {
+        field.Name = formatName(*mojomField.DeclData.ShortName)
+        field.Type = t.translateType(mojomField.Type)
+        field.Tag = mojomField.Tag
+        field.EncodingInfo = t.encodingInfo(mojomField.Type)
+        field.EncodingInfo.setIdentifier("u.Value")
+        return field
+}
+
 func (t *translator) encodingInfo(mojomType mojom_types.Type) EncodingInfo {
         return t.encodingInfoNested(mojomType, 0)
 }
 
 func (t *translator) encodingInfoNested(mojomType mojom_types.Type, level int) (info EncodingInfo) {
         switch m := mojomType.(type) {
         default:
                 panic("This should never happen.")
         case *mojom_types.TypeSimpleType:
                 info = t.simpleTypeEncodingInfo(m.Value)
@@ skipping 142 matching lines @@
         if s[i].Offset == s[j].Offset && s[i].Bit < s[j].Bit {
                 return true
         }
 
         return false
 }
 
 func (s structFieldSerializationSorter) Swap(i, j int) {
         s[i], s[j] = s[j], s[i]
 }