Mojom compiler: Eliminate duplicate representation of enum values in mojom_files.mojom.

mojom/mojom_tool/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 (
         "bytes"
         "compress/gzip"
         "encoding/base64"
@@ skipping 69 matching lines @@
 // Mojo Go representation used for serialization.)
 func translateDescriptor(d *mojom.MojomDescriptor) *mojom_files.MojomFileGraph {
         fileGraph := mojom_files.MojomFileGraph{}
 
         // Add |resolved_types| field.
         fileGraph.ResolvedTypes = make(map[string]mojom_types.UserDefinedType)
         for key, userDefinedType := range d.TypesByKey {
                 fileGraph.ResolvedTypes[key] = translateUserDefinedType(userDefinedType)
         }
 
-        // Add |resolved_values| field.
-        fileGraph.ResolvedValues = make(map[string]mojom_types.UserDefinedValue)
+        // Add |resolved_constants| field.
+        fileGraph.ResolvedConstants = make(map[string]mojom_types.DeclaredConstant)
         for key, userDefinedValue := range d.ValuesByKey {
-                fileGraph.ResolvedValues[key] = translateUserDefinedValue(userDefinedValue)
+                switch c := userDefinedValue.(type) {
+                // Note that our representation of values in mojom_types.mojom is a little different than our
+                // pure Go representation. In the latter we use value keys to refer to both constants and
+                // enum values but in the former we only use value keys to refer to constants. Enum values
+                // are stored as part of their enum types and they are are referred to  not directly using
+                // value keyes but rather via the type key of their enum and an index into the |values| array
+                // of that enum. For this reason we are only looking for the constants here and ignoring the
+                // enum values. Thos will get translated when the
+                case *mojom.UserDefinedConstant:
+                        fileGraph.ResolvedConstants[key] = translateUserDefinedConstant(c)
+                }
         }
 
         // Add |files| field.
         fileGraph.Files = make(map[string]mojom_files.MojomFile)
         for name, file := range d.MojomFilesByName {
                 fileGraph.Files[name] = translateMojomFile(file, &fileGraph)
         }
 
         return &fileGraph
 }
@@ skipping 296 matching lines @@
 }
 
 func translateUnionField(unionField *mojom.UnionField) mojom_types.UnionField {
         outUnionField := mojom_types.UnionField{}
         outUnionField.DeclData = translateDeclarationData(&unionField.DeclarationData)
         outUnionField.Type = translateTypeRef(unionField.FieldType)
         outUnionField.Tag = unionField.Tag
         return outUnionField
 }
 
-// WARNING: Do not invoke this function on a UserDefinedValue of type BuiltInConstantValue because
-// objects of those types do not have a type_key and do not correspond to a mojom_types.UserDefinedValue.
-func translateUserDefinedValue(v mojom.UserDefinedValue) mojom_types.UserDefinedValue {
-        switch t := v.(type) {
-        case *mojom.UserDefinedConstant:
-                return translateUserDefinedConstant(t)
-        case *mojom.EnumValue:
-                return &mojom_types.UserDefinedValueEnumValue{translateEnumValue(t)}
-        case *mojom.BuiltInConstantValue:
-                panic("Do not invoke translateUserDefinedValue on BuiltInConstantValue.")
-        default:
-                panic(fmt.Sprintf("Unexpected UserDefinedValue type %T", v))
-
-        }
-}
-
-func translateUserDefinedConstant(t *mojom.UserDefinedConstant) *mojom_types.UserDefinedValueDeclaredConstant {
-        declaredConstant := mojom_types.UserDefinedValueDeclaredConstant{}
-        declaredConstant.Value.Type = translateTypeRef(t.DeclaredType())
-        declaredConstant.Value.DeclData = *translateDeclarationData(&t.DeclarationData)
-        declaredConstant.Value.Value = translateValueRef(t.ValueRef())
-        // We set the |resolved_concrete_value| field only in the following situation.
-        // See the comments in mojom_types.mojom.
-        if _, ok := declaredConstant.Value.Value.(*mojom_types.ValueUserValueReference); ok {
-                // If the type of the |value| field is a UserValueReference...
-                userValueRef := t.ValueRef().(*mojom.UserValueRef)
-                if _, ok := userValueRef.ResolvedDeclaredValue().(*mojom.UserDefinedConstant); ok {
-                        // and if that reference resolves to a user-defined constant.
-                        declaredConstant.Value.ResolvedConcreteValue = translateConcreteValue(t.ValueRef().ResolvedConcreteValue())
-                }
+func translateUserDefinedConstant(t *mojom.UserDefinedConstant) mojom_types.DeclaredConstant {
+        declaredConstant := mojom_types.DeclaredConstant{}
+        declaredConstant.Type = translateTypeRef(t.DeclaredType())
+        declaredConstant.DeclData = *translateDeclarationData(&t.DeclarationData)
+        declaredConstant.Value = translateValueRef(t.ValueRef())
+        // We set the |resolved_concrete_value| field only in the case that the |value| field is a ConstantReference.
+        // See the comments for this field in mojom_types.mojom.
+        if _, ok := declaredConstant.Value.(*mojom_types.ValueConstantReference); ok {
+                declaredConstant.ResolvedConcreteValue = translateConcreteValue(t.ValueRef().ResolvedConcreteValue())
         }
 
-        return &declaredConstant
+        return declaredConstant
 }
 
 func translateEnumValue(v *mojom.EnumValue) mojom_types.EnumValue {
         enumValue := mojom_types.EnumValue{}
         enumValue.DeclData = translateDeclarationData(&v.DeclarationData)
-        enumValue.EnumTypeKey = v.EnumType().TypeKey()
         if v.ValueRef() != nil {
                 enumValue.InitializerValue = translateValueRef(v.ValueRef())
         }
         if !v.IntValueComputed {
                 panic(fmt.Sprintf("IntValueComputed is false for %v.", v))
         }
         enumValue.IntValue = v.ComputedIntValue
         return enumValue
 }
 
@@ skipping 107 matching lines @@
 
 func translateConcreteValue(cv mojom.ConcreteValue) mojom_types.Value {
         switch cv := cv.(type) {
         case mojom.LiteralValue:
                 return translateLiteralValue(cv)
         // NOTE: See the comments at the top of types.go for a discussion of the difference
         // between a value and a value reference. In this function we are translating a
         // value, not a value reference. In the case of a LiteralValue or a
         // BuiltInConstantValue the distinction is immaterial. But in the case of an
         // enum value the distinction is important. Here we are building and returning
-        // a synthetic mojom_types.UserValueReference to represent the enum value.
-        // It is only the |value_key| field that needs to be populated. It does not
-        // make sense to populate the |identifier| field for example because we
+        // a synthetic mojom_types.EnumValueReference to represent the enum value.
+        // It does not make sense to populate the |identifier| field for because we
         // aren't representing any actual occrence in the .mojom file.
         case *mojom.EnumValue:
-                return &mojom_types.ValueUserValueReference{mojom_types.UserValueReference{
-                        ValueKey: stringPointer(cv.ValueKey())}}
+                return &mojom_types.ValueEnumValueReference{mojom_types.EnumValueReference{
+                        EnumTypeKey:    cv.EnumType().TypeKey(),
+                        EnumValueIndex: cv.ValueIndex()}}
         case mojom.BuiltInConstantValue:
                 return translateBuiltInConstantValue(cv)
         default:
                 panic(fmt.Sprintf("Unexpected ConcreteValue type %T", cv))
         }
 }
 
 func translateLiteralValue(v mojom.LiteralValue) *mojom_types.ValueLiteralValue {
         var lv mojom_types.LiteralValue
         switch v.ValueType() {
@@ skipping 42 matching lines @@
                 builtInValue.Value = mojom_types.BuiltinConstantValue_DoubleNegativeInfinity
         case mojom.DoubleNAN:
                 builtInValue.Value = mojom_types.BuiltinConstantValue_DoubleNan
         default:
                 panic(fmt.Sprintf("Unrecognized BuiltInConstantValue %v", t))
         }
         return &builtInValue
 }
 
 func translateUserValueRef(r *mojom.UserValueRef) mojom_types.Value {
-        switch t := r.ResolvedConcreteValue().(type) {
+        switch t := r.ResolvedDeclaredValue().(type) {
         case mojom.BuiltInConstantValue:
                 return translateBuiltInConstantValue(t)
+        case *mojom.UserDefinedConstant:
+                return &mojom_types.ValueConstantReference{mojom_types.ConstantReference{
+                        Identifier:  r.Identifier(),
+                        ConstantKey: t.ValueKey()}}
+        case *mojom.EnumValue:
+                return &mojom_types.ValueEnumValueReference{mojom_types.EnumValueReference{
+                        Identifier:     r.Identifier(),
+                        EnumTypeKey:    t.EnumType().TypeKey(),
+                        EnumValueIndex: t.ValueIndex()}}
         default:
-                valueKey := stringPointer(r.ResolvedDeclaredValue().ValueKey())
-                return &mojom_types.ValueUserValueReference{mojom_types.UserValueReference{
-                        Identifier: r.Identifier(),
-                        ValueKey:   valueKey}}
+                panic(fmt.Sprintf("Unrecognized UserDefinedValueType %T", r.ResolvedDeclaredValue()))
         }
 }
 
 func translateDeclarationData(d *mojom.DeclarationData) *mojom_types.DeclarationData {
         declData := mojom_types.DeclarationData{}
 
         // attributes field
         if d.Attributes() != nil {
                 declData.Attributes = new([]mojom_types.Attribute)
                 for _, attr := range d.Attributes().List {
@@ skipping 90 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
 }