Mojo: Add support for constants to the IDL compiler.

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

 # Copyright 2013 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.
 
 # TODO(vtl): "data" is a pretty vague name. Rename it?
 
 import copy
 
 import module as mojom
 
@@ skipping 47 matching lines @@
       test_spec = 'x:'
       if i > 0:
         test_spec += '.'.join(scope[:i]) + '.'
       test_spec += name
       kind = kinds.get(test_spec)
       if kind:
         return kind
 
   return kinds.get(spec)
 
-def LookupConstant(constants, name, scope):
-  """Like LookupKind, but for constants."""
+def LookupValue(values, name, scope):
+  """Like LookupKind, but for constant values."""
   for i in xrange(len(scope), -1, -1):
     if i > 0:
       test_spec = '.'.join(scope[:i]) + '.'
     test_spec += name
-    constant = constants.get(test_spec)
-    if constant:
-      return constant
+    value = values.get(test_spec)
+    if value:
+      return value
 
-  return constants.get(name)
+  return values.get(name)
 
 def KindToData(kind):
   return kind.spec
 
 def KindFromData(kinds, data, scope):
   kind = LookupKind(kinds, data, scope)
   if kind:
     return kind
   if data.startswith('a:'):
     kind = mojom.Array()
@@ skipping 18 matching lines @@
   import_item['module_name'] = import_module.name
   import_item['namespace'] = import_module.namespace
   import_item['module'] = import_module
 
   # Copy the struct kinds from our imports into the current module.
   for kind in import_module.kinds.itervalues():
     if (isinstance(kind, (mojom.Struct, mojom.Enum)) and
         kind.imported_from is None):
       kind = KindFromImport(kind, import_item)
       module.kinds[kind.spec] = kind
-  # Ditto for constants.
-  for constant in import_module.constants.itervalues():
-    if constant.imported_from is None:
-      constant = copy.deepcopy(constant)
-      constant.imported_from = import_item
-      module.constants[constant.GetSpec()] = constant
+  # Ditto for values.
+  for value in import_module.values.itervalues():
+    if value.imported_from is None:
+      value = copy.deepcopy(value)
+      value.imported_from = import_item
+      module.values[value.GetSpec()] = value
 
   return import_item
 
 def StructToData(struct):
   return {
     istr(0, 'name'): struct.name,
     istr(1, 'fields'): map(FieldToData, struct.fields)
   }
 
 def StructFromData(module, data):
   struct = mojom.Struct(module=module)
   struct.name = data['name']
   struct.attributes = data['attributes']
   struct.spec = 'x:' + module.namespace + '.' + struct.name
   module.kinds[struct.spec] = struct
   struct.enums = map(lambda enum:
       EnumFromData(module, enum, struct), data['enums'])
+  struct.constants = map(lambda constant:
+      ConstantFromData(module, constant, struct), data['constants'])
   # Stash fields data here temporarily.
   struct.fields_data = data['fields']
   return struct
 
 def FieldToData(field):
   data = {
     istr(0, 'name'): field.name,
     istr(1, 'kind'): KindToData(field.kind)
   }
   if field.ordinal != None:
     data[istr(2, 'ordinal')] = field.ordinal
   if field.default != None:
     data[istr(3, 'default')] = field.default
   return data
 
 def FixupExpression(module, value, scope):
   if isinstance(value, (tuple, list)):
     for i in xrange(len(value)):
       if isinstance(value, tuple):
         FixupExpression(module, value[i], scope)
       else:
         value[i] = FixupExpression(module, value[i], scope)
   elif value:
-    constant = LookupConstant(module.constants, value, scope)
-    if constant:
-      return constant
+    result = LookupValue(module.values, value, scope)
+    if result:
+      return result
   return value
 
 def FieldFromData(module, data, struct):
   field = mojom.Field()
   field.name = data['name']
   field.kind = KindFromData(
       module.kinds, data['kind'], (module.namespace, struct.name))
   field.ordinal = data.get('ordinal')
   field.default = FixupExpression(
       module, data.get('default'), (module.namespace, struct.name))
@@ skipping 52 matching lines @@
   }
 
 def InterfaceFromData(module, data):
   interface = mojom.Interface(module=module)
   interface.name = data['name']
   interface.spec = 'x:' + module.namespace + '.' + interface.name
   interface.peer = data['peer'] if data.has_key('peer') else None
   module.kinds[interface.spec] = interface
   interface.enums = map(lambda enum:
       EnumFromData(module, enum, interface), data['enums'])
+  interface.constants = map(lambda constant:
+      ConstantFromData(module, constant, interface), data['constants'])
   # Stash methods data here temporarily.
   interface.methods_data = data['methods']
   return interface
 
 def EnumFieldFromData(module, enum, data, parent_kind):
   field = mojom.EnumField()
   field.name = data['name']
+  # TODO(mpcomplete): FixupExpression should be done in the second pass,
+  # so constants and enums can refer to each other.
+  # TODO(mpcomplete): But then, what if constants are initialized to an enum? Or
+  # vice versa?
   if parent_kind:
     field.value = FixupExpression(
         module, data['value'], (module.namespace, parent_kind.name))
   else:
     field.value = FixupExpression(
         module, data['value'], (module.namespace, ))
-  constant = mojom.Constant(module, enum, field)
-  module.constants[constant.GetSpec()] = constant
+  value = mojom.EnumValue(module, enum, field)
+  module.values[value.GetSpec()] = value
   return field
 
 def EnumFromData(module, data, parent_kind):
   enum = mojom.Enum(module=module)
   enum.name = data['name']
   name = enum.name
   if parent_kind:
     name = parent_kind.name + '.' + name
   enum.spec = 'x:%s.%s' % (module.namespace, name)
   enum.parent_kind = parent_kind
 
   enum.fields = map(
       lambda field: EnumFieldFromData(module, enum, field, parent_kind),
       data['fields'])
   module.kinds[enum.spec] = enum
   return enum
 
+def ConstantFromData(module, data, parent_kind):
+  constant = mojom.Constant()
+  constant.name = data['name']
+  if parent_kind:
+    scope = (module.namespace, parent_kind.name)
+  else:
+    scope = (module.namespace, )
+  # TODO(mpcomplete): maybe we should only support POD kinds.
+  constant.kind = KindFromData(module.kinds, data['kind'], scope)
+  constant.value = FixupExpression(module, data.get('value'), scope)
+
+  value = mojom.NamedValue(module, parent_kind, constant.name)
+  module.values[value.GetSpec()] = value
+  return constant
+
 def ModuleToData(module):
   return {
     istr(0, 'name'):       module.name,
     istr(1, 'namespace'):  module.namespace,
     istr(2, 'structs'):    map(StructToData, module.structs),
     istr(3, 'interfaces'): map(InterfaceToData, module.interfaces)
   }
 
 def ModuleFromData(data):
   module = mojom.Module()
   module.kinds = {}
   for kind in mojom.PRIMITIVES:
     module.kinds[kind.spec] = kind
 
-  module.constants = {}
+  module.values = {}
 
   module.name = data['name']
   module.namespace = data['namespace']
   module.attributes = data['attributes']
   # Imports must come first, because they add to module.kinds which is used
   # by by the others.
   module.imports = map(
       lambda import_data: ImportFromData(module, import_data),
       data['imports'])
 
   # First pass collects kinds.
   module.enums = map(
       lambda enum: EnumFromData(module, enum, None), data['enums'])
   module.structs = map(
       lambda struct: StructFromData(module, struct), data['structs'])
   module.interfaces = map(
       lambda interface: InterfaceFromData(module, interface),
       data['interfaces'])
+  module.constants = map(
+      lambda constant: ConstantFromData(module, constant, None),
+      data['constants'])
 
   # Second pass expands fields and methods. This allows fields and parameters
   # to refer to kinds defined anywhere in the mojom.
   for struct in module.structs:
     struct.fields = map(lambda field:
         FieldFromData(module, field, struct), struct.fields_data)
     del struct.fields_data
   for interface in module.interfaces:
     interface.methods = map(lambda method:
         MethodFromData(module, method, interface), interface.methods_data)
     del interface.methods_data
 
   return module
 
 def OrderedModuleFromData(data):
   module = ModuleFromData(data)
   next_interface_ordinal = 0
   for interface in module.interfaces:
     next_ordinal = 0
     for method in interface.methods:
       if method.ordinal is None:
         method.ordinal = next_ordinal
       next_ordinal = method.ordinal + 1
   return module