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

mojo/public/tools/bindings/pylib/mojom/generate/mojom_translator.py

 #!/usr/bin/env python
 # 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.
 #
 # This module is responsible for translating a MojomFileGraph (see
 # mojom_files.mojom) to one or more module.Module.
 #
 # This module takes the output of the mojom parser, a MojomFileGraph  and
 # translates it to the input of the code generators, a module.Module object.
@@ skipping 55 matching lines @@
     mod.imports = []
     self._transitive_imports = self.GetTransitiveImports(mojom_file)
     mod.transitive_imports = self._transitive_imports.values()
     if mojom_file.imports:
       mod.imports = [
           self._transitive_imports[imp] for imp in mojom_file.imports]
 
     if mojom_file.declared_mojom_objects:
       if mojom_file.declared_mojom_objects.top_level_constants:
         mod.constants = [
-            self.ConstantFromValueKey(key)
+            self.ConstantFromKey(key)
             for key in mojom_file.declared_mojom_objects.top_level_constants]
 
       user_defined_types = ['interfaces', 'structs', 'unions']
       for user_defined_type in user_defined_types:
         if getattr(mojom_file.declared_mojom_objects, user_defined_type):
           setattr(mod, user_defined_type, [self.UserDefinedFromTypeKey(key)
             for key in getattr(
               mojom_file.declared_mojom_objects, user_defined_type)])
       if mojom_file.declared_mojom_objects.top_level_enums:
         mod.enums = [self.UserDefinedFromTypeKey(key)
@@ skipping 242 matching lines @@
     if not contained_declarations:
       return
 
     if contained_declarations.enums:
       for enum_key in contained_declarations.enums:
         enum = self.UserDefinedFromTypeKey(enum_key)
         parent_kind.enums.append(enum)
 
     if contained_declarations.constants:
       for const_key in contained_declarations.constants:
-        const = self.ConstantFromValueKey(const_key)
+        const = self.ConstantFromKey(const_key)
         parent_kind.constants.append(const)
 
   def EnumFromMojom(self, enum, mojom_type):
     """Populates a module.Enum based on a MojomEnum.
 
     Args:
       enum: {module.Enum} to be populated.
       mojom_type: {mojom_types_mojom.Type} referring to the MojomEnum to be
         translated.
     """
@@ skipping 154 matching lines @@
       # translated struct to a value that the code generators are expecting.
       method.response_param_struct.name = "%s_%s_ResponseParams" % (
           method.interface.name, method.name)
       method.response_parameters = [self.ParamFromMojom(param)
           for param in mojom_method.response_params.fields]
 
     method.min_version=mojom_method.min_version
 
     return method
 
-  def ConstantFromValueKey(self, value_key):
-    """Takes a value key into a graph.resolved_values referring to a constant
-    and returns the module equivalent.
+  def ConstantFromKey(self, constant_key):
+    """Takes a key into the map graph.resolved_constants and returns the module
+    equivalent constant.
 
     Args:
-      value_key: {str} the value key referring to the value to be returned.
+      constant_key: {str} the key referring to the constant whose translation
+        is to be returned.
 
     Returns:
       {module.Constant} translated.
     """
-    if value_key in self._constant_cache:
-      return self._constant_cache[value_key]
+    if constant_key in self._constant_cache:
+      return self._constant_cache[constant_key]
 
-    mojom_const = self._graph.resolved_values[value_key].declared_constant
+    mojom_const = self._graph.resolved_constants[constant_key]
     const = module.Constant()
-    self._constant_cache[value_key] = const
+    self._constant_cache[constant_key] = const
 
     self.ConstantFromMojom(const, mojom_const)
     return const
 
   def ConstantFromMojom(self, const, mojom_const):
     """Populates a module.Constant based on a DeclaredConstant.
 
     Args:
       const: {module.Constant} to be populated.
       mojom_const: {mojom_types_mojom.DeclaredConstant} to be translated.
@@ skipping 51 matching lines @@
           'double.NEGATIVE_INFINITY',
         mojom_types_mojom.BuiltinConstantValue.DOUBLE_NAN:
           'double.NAN',
         mojom_types_mojom.BuiltinConstantValue.FLOAT_INFINITY:
           'float.INFINITY',
         mojom_types_mojom.BuiltinConstantValue.FLOAT_NEGATIVE_INFINITY:
           'float.NEGATIVE_INFINITY',
         mojom_types_mojom.BuiltinConstantValue.FLOAT_NAN: 'float.NAN',
           }
       return module.BuiltinValue(mojom_to_builtin[value.builtin_value])
+    return self.FromUserValueReference(value)
 
-    assert value.tag == mojom_types_mojom.Value.Tags.user_value_reference
-    return self.UserDefinedFromValueKey(value.user_value_reference.value_key)
-
-  def UserDefinedFromValueKey(self, value_key):
-    """Takes a value key into graph.resolved_values and returns the module
-    equivalent.
+  def FromUserValueReference(self, value):
+    """Translates a mojom_types.EnumValueReference or ConstantReference into the
+    module equivalent.
 
     Args:
-      value_key: {str} the value key referring to the value to be returned.
+      value: {mojom_types_mojom.Value} the value ref to be translated. It
+      must be of type EnumValueReference or ConstantReference.
 
     Returns:
       {module.EnumValue|module.ConstantValue} translated.
     """
-    if value_key in self._value_cache:
-      return self._value_cache[value_key]
+    if value.tag == mojom_types_mojom.Value.Tags.constant_reference:
+      return self.ConstantValueFromKey(value.constant_reference.constant_key)
+    assert value.tag == mojom_types_mojom.Value.Tags.enum_value_reference
+    return self.EnumValueFromKey(value.enum_value_reference.enum_type_key,
+        value.enum_value_reference.enum_value_index)
 
-    value = self._graph.resolved_values[value_key]
-    if value.tag == mojom_types_mojom.UserDefinedValue.Tags.enum_value:
-      return self.EnumValueFromMojom(value.enum_value)
-    return self.ConstantValueFromValueKey(value_key)
-
-  def ConstantValueFromValueKey(self, value_key):
-    """Takes a value key into graph.resolved_values referring to a declared
-    constant and returns the module equivalent.
+  def ConstantValueFromKey(self, constant_key):
+    """Takes a key into graph.resolved_constants referring to a
+    mojom declared_constant and returns a module.ConstantValue referring to the
+    module equivalent constant.
 
     Args:
-      value_key: {str} the value key referring to the value to be returned.
+      constant_key: {str} the constant key referring to a constant.
 
     Returns:
       {module.ConstantValue} translated.
     """
+    if constant_key in self._value_cache:
+      return self._value_cache[constant_key]
+
     const_value = module.ConstantValue()
-    self._value_cache[value_key] = const_value
+    self._value_cache[constant_key] = const_value
 
-    const = self.ConstantFromValueKey(value_key)
+    const = self.ConstantFromKey(constant_key)
     const_value.constant = const
     const_value.name = const.name
     const_value.parent_kind = const.parent_kind
     self.PopulateModuleOrImportedFrom(const_value,
-        self._graph.resolved_values[value_key].declared_constant)
+        self._graph.resolved_constants[constant_key])
     const_value.namespace = const_value.module.namespace
     return const_value
 
-  def EnumValueFromMojom(self, mojom_enum_value):
-    """Translates an mojom_types_mojom.EnumValue to a module.EnumValue.
+  def EnumValueFromKey(self, enum_type_key, enum_value_index):
+    """Takes an enum type key and an enum value index (together these
+    form a key to a mojom_enum_value) and returns a module.EnumValue referring
+    the module equivalent enum value
 
-    mojom_enum_value: {mojom_types_mojom.EnumValue} to be translated.
+    Args:
+      enum_type_key: {str} the type key of a mojom_enum
+      enum_value_index: {int} the 0-based index into the |values| array of
+        the mojom_enum
 
     Returns:
       {module.EnumValue} translated from mojom_enum_value.
     """
-    enum_type_key = mojom_enum_value.enum_type_key
-    name = mojom_enum_value.decl_data.short_name
-    value_key = (enum_type_key, name)
-    if value_key in self._value_cache:
-      return self._value_cache[value_key]
+    enum_value_key = (enum_type_key, enum_value_index)
+    if enum_value_key in self._value_cache:
+      return self._value_cache[enum_value_key]
+
+    mojom_enum = self._graph.resolved_types[enum_type_key].enum_type
+    mojom_enum_value = mojom_enum.values[enum_value_index]
 
     # We need to create and cache the EnumValue object just in case later calls
     # require the creation of that same EnumValue object.
     enum_value = module.EnumValue()
-    self._value_cache[value_key] = enum_value
+    self._value_cache[enum_value_key] = enum_value
 
     enum = self.UserDefinedFromTypeKey(enum_type_key)
     enum_value.enum = enum
     self.PopulateModuleOrImportedFrom(enum_value, mojom_enum_value)
     enum_value.namespace = enum_value.module.namespace
     enum_value.parent_kind = enum.parent_kind
-    enum_value.name = name
+    enum_value.name = mojom_enum_value.decl_data.short_name
 
     return enum_value
 
   def KindFromMojom(self, mojom_type):
     """Translates a mojom_types_mojom.Type to its equivalent module type.
 
     It is guaranteed that two calls to KindFromMojom with the same input yield
     the same object.
 
     Args:
@@ skipping 204 matching lines @@
 
   Args:
     graph: {mojom_types_mojom.MojomFileGraph} to be translated.
 
   Return:
     {dict<str, module.Module>} mapping the file's name to its module.Module
     translation for all files in graph.files.
   """
   return {file_name: FileTranslator(graph, file_name).Translate()
       for file_name in graph.files}