Improves the representation of values in 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 47 matching lines @@
     mod = self._module
     self.PopulateModuleMetadata(mod, mojom_file)
     mod.imports = [self.ImportFromMojom(imp) for imp in mojom_file.imports]
     # TODO(azani): The key should be equal to SourceFileInfo.file_name of
     # imported types.
     self._imports = {imp['module'].path: imp for imp in mod.imports}
 
     if mojom_file.declared_mojom_objects:
       if mojom_file.declared_mojom_objects.top_level_constants:
         mod.constants = [
-            self.ConstFromMojom(self._graph.resolved_constants[key], None)
+            self.ConstFromMojom(
+                self._graph.resolved_values[key].declared_constant, None)
             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 84 matching lines @@
     Args:
       mojom_field: {mojom_types_mojom.StructField} to be translated.
 
     Returns:
       {module.StructField} translated from mojom_field.
     """
     struct_field = module.StructField()
     self.PopulateCommonFieldValues(struct_field, mojom_field)
     struct_field.ordinal = self.OrdinalFromMojom(mojom_field)
     if mojom_field.default_value:
-      struct_field.default = self.EvalConst(mojom_field.default_value)
+      if (mojom_field.default_value.tag ==
+          mojom_types_mojom.DefaultFieldValue.Tags.default_keyword):
+        struct_field.default = 'default'
+      else:
+        struct_field.default = self.EvalValue(
+            mojom_field.default_value.value)
 
     return struct_field
 
   def ParamFromMojom(self, mojom):
     """Translates a mojom_types_mojom.StructField to a module.Parameter.
 
     The parameters passed to and returned from a method are expressed as a
     struct. The struct fields in the struct are the parameters.
 
     Args:
       mojom: {mojom_types_mojom.StructField} representing a method parameter.
 
     Returns:
       {module.Parameter} translated from the mojom.
     """
     param = module.Parameter()
     param.ordinal = self.OrdinalFromMojom(mojom)
-    if mojom.default_value:
-      param.default = self.EvalConst(mojom.default_value)
     self.PopulateCommonFieldValues(param, mojom)
     return param
 
   def PopulateCommonFieldValues(self, field, mojom_field):
     """Populates a number of common field values based on a mojom field.
 
     Args:
       field: {module.Field|module.Parameter} to be populated.
       mojom_field: {StructField|UnionField} to be translated.
     """
@@ skipping 21 matching lines @@
     """Translates an mojom_types_mojom.EnumValue to a module.EnumField.
 
     mojom_field: {mojom_types_mojom.EnumValue} to be translated.
 
     Returns:
       {module.EnumField} translated from mojom_field.
     """
     field = module.EnumField()
     field.name = mojom_field.decl_data.short_name
     field.attributes = self.AttributesFromMojom(mojom_field)
-    field.value = self.EvalConst(mojom_field.value)
-    field.numeric_value = self.EvalConst(mojom_field.value)
+    field.value = mojom_field.int_value
+    field.numeric_value = mojom_field.int_value
     return field
 
   def AttributesFromMojom(self, mojom):
     """Extracts the attributes from a Mojom object into a dict.
 
     Args:
       mojom: A type in mojom_types_mojom containing a decl_data field.
 
     Returns:
       {dict<str, str>} of the attributes.
@@ skipping 89 matching lines @@
       mojom_const: {mojom_types_mojom.DeclaredConstant} to be translated.
       parent_kind: {module.Struct|Interface} if the constant is nested in a
         struct or interface.
 
     Returns:
       {module.Constant} translated from mojom_const.
     """
     const = module.Constant()
     const.name = mojom_const.decl_data.short_name
     const.kind = self.KindFromMojom(mojom_const.type)
-    const.value = self.EvalConst(mojom_const.value)
+    const.value = self.EvalValue(mojom_const.value)
     const.parent_kind = parent_kind
     return const
 
-  def EvalConst(self, const):
-    """Evaluates a mojom_types_mojom.ConstantValue.
+  def EvalValue(self, value):
+    """Evaluates a mojom_types_mojom.Value.
 
     Args:
-      const: {mojom_types_mojom.ConstantValue} to be evaluated.
+      value: {mojom_types_mojom.Value} to be evaluated.
 
     Returns:
-      {int|float|str|bool} either the value of the constant or a string
-      referencing a built-in constant value.
+      {int|float|str|bool|None} the literal value if value is a LiteralValue,
+      the string name of the built-in constant if value is a
+      BuiltinConstantValue, the result of invoking EvalValue() on the
+      resolved concrete value of the user value reference if value is a
+      UserValueReference and its concrete value is not None, or else None
     """
-    if const.value.tag == mojom_types_mojom.ConstantValue.Tags.builtin_value:
+    if value.tag == mojom_types_mojom.Value.Tags.literal_value:
+      return value.literal_value.data
+    elif value.tag == mojom_types_mojom.Value.Tags.builtin_value:
       mojom_to_builtin = {
         mojom_types_mojom.BuiltinConstantValue.DOUBLE_INFINITY:
           'double.INFINITY',
         mojom_types_mojom.BuiltinConstantValue.DOUBLE_NEGATIVE_INFINITY:
           'double.NEGATIVE_INFINITY',
         mojom_types_mojom.BuiltinConstantValue.DOUBLE_NAN:
           'double.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[const.value.builtin_value])
+      return module.BuiltinValue(mojom_to_builtin[value.builtin_value])
 
-    return const.value.data
+    assert value.tag == mojom_types_mojom.Value.Tags.user_value_reference
+    concrete_value = value.user_value_reference.resolved_concrete_value
+    if concrete_value == None:
+      return None
+    assert (concrete_value.tag !=
+        mojom_types_mojom.Value.Tags.user_value_reference)
+    return self.EvalValue(concrete_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:
       mojom_type: {mojom_types_mojom.Type} to be translated.
 
@@ skipping 190 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}