Generate Mojom Types in Go

mojo/public/tools/bindings/generators/mojom_go_generator.py

 # 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.
 
 '''Generates Go source files from a mojom.Module.'''
 
 from itertools import chain
+import base64

[azani, 2015/10/19 18:27:02]

unused?

[alexfandrianto, 2015/10/19 21:36:30]

Done. Yes, it was unused. I was using it earlier for the identifier but decided
against it.

 import os
 import re
 
 from mojom.generate.template_expander import UseJinja
 
 import mojom.generate.generator as generator
 import mojom.generate.module as mojom
 import mojom.generate.pack as pack
 
 class KindInfo(object):
@@ skipping 32 matching lines @@
       'system.MessagePipeHandle', 'Handle', 'MessagePipeHandle', 32),
   mojom.NULLABLE_SHAREDBUFFER: KindInfo(
       'system.SharedBufferHandle', 'Handle', 'SharedBufferHandle', 32),
   mojom.INT64:                 KindInfo('int64', 'Int64', 'Int64', 64),
   mojom.UINT64:                KindInfo('uint64', 'Uint64', 'Uint64', 64),
   mojom.DOUBLE:                KindInfo('float64', 'Float64', 'Float64', 64),
   mojom.STRING:                KindInfo('string', 'String', 'String', 64),
   mojom.NULLABLE_STRING:       KindInfo('string', 'String', 'String', 64),
 }
 
+# _imports keeps track of the imports that the .go.mojom file needs to import.
 _imports = {}
 
+# _mojom_imports keeps a list of the other .mojom files imported by this one.
+_mojom_imports = {}
+
+# The mojom_types.mojom and service_describer.mojom files are special because
+# they are used to generate mojom Type's and ServiceDescription implementations.
+_service_describer_pkg_short = "service_describer"
+_service_describer_pkg = "mojo/public/interfaces/bindings/%s" % \
+  _service_describer_pkg_short
+_mojom_types_pkg_short = "mojom_types"
+_mojom_types_pkg = "mojo/public/interfaces/bindings/%s" % _mojom_types_pkg_short
+
 def GetBitSize(kind):
   if isinstance(kind, (mojom.Union)):
     return 128
   if isinstance(kind, (mojom.Array, mojom.Map, mojom.Struct, mojom.Interface)):
     return 64
   if mojom.IsUnionKind(kind):
     return 2*64
   if isinstance(kind, (mojom.InterfaceRequest)):
     kind = mojom.MSGPIPE
   if isinstance(kind, mojom.Enum):
@@ skipping 107 matching lines @@
 
 def EncodeSuffix(kind):
   if mojom.IsEnumKind(kind):
     return EncodeSuffix(mojom.INT32)
   if mojom.IsInterfaceKind(kind):
     return 'Interface'
   if mojom.IsInterfaceRequestKind(kind):
     return EncodeSuffix(mojom.MSGPIPE)
   return _kind_infos[kind].encode_suffix
 
+# This helper assists in the production of mojom_types.Type for simple kinds.
+# See _kind_infos above.
+def GetMojomTypeValue(kind, typepkg=''):
+  if not kind in _kind_infos:
+    return ''
+  if kind == mojom.BOOL:
+    return '%sTypeSimpleType{%sSimpleType_Bool}' % (typepkg, typepkg)

[azani, 2015/10/19 18:27:02]

There is a lot of repetition in those strings. You should be able to factor out
some common parts.

Also, instead of so many elifs you should be able to use dicts with kinds as the
keys.

[alexfandrianto, 2015/10/19 21:36:30]

It's a bit smaller now. Unfortunately, I had to hardcode the handle kind_names.

+  elif kind == mojom.INT8:
+    return '%sTypeSimpleType{%sSimpleType_InT8}' % (typepkg, typepkg)
+  elif kind == mojom.UINT8:
+    return '%sTypeSimpleType{%sSimpleType_UinT8}' % (typepkg, typepkg)
+  elif kind == mojom.INT16:
+    return '%sTypeSimpleType{%sSimpleType_InT16}' % (typepkg, typepkg)
+  elif kind == mojom.UINT16:
+    return '%sTypeSimpleType{%sSimpleType_UinT16}' % (typepkg, typepkg)
+  elif kind == mojom.INT32:
+    return '%sTypeSimpleType{%sSimpleType_InT32}' % (typepkg, typepkg)
+  elif kind == mojom.UINT32:
+    return '%sTypeSimpleType{%sSimpleType_UinT32}' % (typepkg, typepkg)
+  elif kind == mojom.INT64:
+    return '%sTypeSimpleType{%sSimpleType_InT64}' % (typepkg, typepkg)

[azani, 2015/10/19 18:27:02]

I could be wrong, but InT64 does not look right to me.

[alexfandrianto, 2015/10/19 21:36:30]

It looks weird to me too. It's an artifact of sending something with ALLCAPS and
trailing digits to the UpperCamelCase and NameToComponent code.

+  elif kind == mojom.UINT64:
+    return '%sTypeSimpleType{%sSimpleType_UinT64}' % (typepkg, typepkg)
+  elif kind == mojom.FLOAT:
+    return '%sTypeSimpleType{%sSimpleType_Float}' % (typepkg, typepkg)
+  elif kind == mojom.DOUBLE:
+    return '%sTypeSimpleType{%sSimpleType_Double}' % (typepkg, typepkg)
+  elif kind == mojom.HANDLE:
+    return '%sTypeHandleType{%sHandleType{Nullable: false, Kind: %sHandleType_Kind_Unspecified}}' % (typepkg, typepkg, typepkg)
+  elif kind == mojom.DCPIPE:
+    return '%sTypeHandleType{%sHandleType{Nullable: false, Kind: %sHandleType_Kind_DataPipeConsumer}}' % (typepkg, typepkg, typepkg)
+  elif kind == mojom.DPPIPE:
+    return '%sTypeHandleType{%sHandleType{Nullable: false, Kind: %sHandleType_Kind_DataPipeProducer}}' % (typepkg, typepkg, typepkg)
+  elif kind == mojom.MSGPIPE:
+    return '%sTypeHandleType{%sHandleType{Nullable: false, Kind: %sHandleType_Kind_MessagePipe}}' % (typepkg, typepkg, typepkg)
+  elif kind == mojom.SHAREDBUFFER:
+    return '%sTypeHandleType{%sHandleType{Nullable: false, Kind: %sHandleType_Kind_SharedBuffer}}' % (typepkg, typepkg, typepkg)
+  elif kind == mojom.NULLABLE_HANDLE:
+    return '%sTypeHandleType{%sHandleType{Nullable: true, Kind: %sHandleType_Kind_Unspecified}}' % (typepkg, typepkg, typepkg)
+  elif kind == mojom.NULLABLE_DCPIPE:
+    return '%sTypeHandleType{%sHandleType{Nullable: true, Kind: %sHandleType_Kind_DataPipeConsumer}}' % (typepkg, typepkg, typepkg)
+  elif kind == mojom.NULLABLE_DPPIPE:
+    return '%sTypeHandleType{%sHandleType{Nullable: true, Kind: %sHandleType_Kind_DataPipeProducer}}' % (typepkg, typepkg, typepkg)
+  elif kind == mojom.NULLABLE_MSGPIPE:
+    return '%sTypeHandleType{%sHandleType{Nullable: true, Kind: %sHandleType_Kind_MessagePipe}}' % (typepkg, typepkg, typepkg)
+  elif kind == mojom.NULLABLE_SHAREDBUFFER:
+    return '%sTypeHandleType{%sHandleType{Nullable: true, Kind: %sHandleType_Kind_SharedBuffer}}' % (typepkg, typepkg, typepkg)
+  elif kind == mojom.STRING:
+    return '%sTypeStringType{%sStringType{false}}' % (typepkg, typepkg)
+  elif kind == mojom.NULLABLE_STRING:
+    return '%sTypeStringType{%sStringType{true}}' % (typepkg, typepkg)
+  else:
+    raise Exception('Missing case for kind: %s' % kind)
+
 def GetPackageName(module):
   return module.name.split('.')[0]
 
-def GetPackageNameForElement(element):
+def GetPackageNameForElement(element, default=''):

[azani, 2015/10/19 18:27:02]

It looks like the default logic is only used when this function is invoked by
GetIdentifier. Maybe push that logic one level up? If the returned string is
empty, use default.

[alexfandrianto, 2015/10/19 21:36:30]

Done.

   if not hasattr(element, 'imported_from') or not element.imported_from:
-    return ''
+    return default
   path = ''
   if element.imported_from['module'].path:
     path += GetPackagePath(element.imported_from['module'])
   if path in _imports:
     return _imports[path]
-  return ''
+  return default
 
 def GetQualifiedName(name, package=None, exported=True):
   if not package:
     return FormatName(name, exported)
   return '%s.%s' % (package, FormatName(name, exported))
 
 def GetPackagePath(module):
   name = module.name.split('.')[0]
   return '/'.join(module.path.split('/')[:-1] + [name])
 
 def GetAllConstants(module):
   data = [module] + module.structs + module.interfaces
   constants = [x.constants for x in data]
   return [i for i in chain.from_iterable(constants)]
 
 def GetAllEnums(module):
   data = [module] + module.structs + module.interfaces
   enums = [x.enums for x in data]
   return [i for i in chain.from_iterable(enums)]
 
 # Adds an import required to use the provided |element|.
 # The required import is stored at '_imports'.
+# The mojom imports are also stored separately in '_mojom_imports'.
 def AddImport(module, element):
   if not isinstance(element, mojom.Kind):
     return
 
   if mojom.IsArrayKind(element) or mojom.IsInterfaceRequestKind(element):
     AddImport(module, element.kind)
     return
   if mojom.IsMapKind(element):
     AddImport(module, element.key_kind)
     AddImport(module, element.value_kind)
     return
   if mojom.IsAnyHandleKind(element):
     _imports['mojo/public/go/system'] = 'system'
     return
 
   if not hasattr(element, 'imported_from') or not element.imported_from:
     return
   imported = element.imported_from
   if GetPackagePath(imported['module']) == GetPackagePath(module):
     return
   path = GetPackagePath(imported['module'])
   if path in _imports:
     return
   name = GetPackageName(imported['module'])
-  while name in _imports.values():
+  while name in _imports.values(): # This avoids repeated names.
     name += '_'
   _imports[path] = name
+  _mojom_imports[path] = name
 
+# The identifier cache is used by the Type generator to determine if a type has
+# already been generated or not. This prevents over-generation of the same type
+# when it is referred to in multiple ways.
+identifier_cache = {}
+def GetIdentifier(kind, default):
+  package = GetPackageNameForElement(kind, default)

[azani, 2015/10/19 18:27:02]

I think what you are looking for that you pass in as default is in kind.module.

[alexfandrianto, 2015/10/19 21:36:30]

Changed a little bit. Unfortunately, kind.module doesn't always exist, so I
still need the default.

[azani, 2015/10/19 21:43:07]

I would expect that kind.module would exist for all user-defined types that are
not imported. Is that not the case?

+
+  # Most kinds have a name, but those that don't should rely on their spec.
+  # Since spec can have : and ? characters, these must be replaced. Since ? is
+  # replaced with '', the caller must keep track of optionality on its own.
+  package_unique = (kind.name if hasattr(kind, 'name') else kind.spec).replace(':', '_').replace('?', '')
+  return '%s_%s' % (package, package_unique)
+
+def StoreIdentifier(identifier, cache_name):
+  if not cache_name in identifier_cache:
+    identifier_cache[cache_name] = {}
+  identifier_cache[cache_name][identifier] = True
+  return ''
+
+def CheckIdentifier(identifier, cache_name):
+  if not cache_name in identifier_cache:
+    identifier_cache[cache_name] = {}
+  return identifier in identifier_cache[cache_name]
+
+# Get the mojom type's identifier suffix.
+def GetMojomTypeIdentifier(kind, default):
+  # Since this should be unique, it is based on the type's identifier.
+  return "%s__" % GetIdentifier(kind, default)
 
 class Generator(generator.Generator):
   go_filters = {
     'array': lambda kind: mojom.Array(kind),
     'bit_size': GetBitSize,
     'decode_suffix': DecodeSuffix,
     'encode_suffix': EncodeSuffix,
     'go_type': GetGoType,
     'expression_to_text': ExpressionToText,
     'has_response': lambda method: method.response_parameters is not None,
+    'identifier': GetIdentifier,
+    'identifier_check': CheckIdentifier,
+    'identifier_store': StoreIdentifier,
     'is_array': mojom.IsArrayKind,
     'is_enum': mojom.IsEnumKind,
     'is_handle': mojom.IsAnyHandleKind,
     'is_interface': mojom.IsInterfaceKind,
     'is_interface_request': mojom.IsInterfaceRequestKind,
     'is_map': mojom.IsMapKind,
     'is_none_or_empty': lambda array: array is None or len(array) == 0,
     'is_nullable': mojom.IsNullableKind,
     'is_pointer': IsPointer,
     'is_object': mojom.IsObjectKind,
     'is_struct': mojom.IsStructKind,
     'is_union': mojom.IsUnionKind,
     'qualified': GetQualifiedName,
+    'mojom_type': GetMojomTypeValue,
+    'mojom_type_identifier': GetMojomTypeIdentifier,
     'name': GetNameForElement,
     'unqualified_name': GetUnqualifiedNameForElement,
     'package': GetPackageNameForElement,
     'tab_indent': lambda s, size = 1: ('\n' + '\t' * size).join(s.splitlines())
   }
 
   def GetParameters(self):
+    package = GetPackageName(self.module)
     return {
       'enums': GetAllEnums(self.module),
-      'imports': self.GetImports(),
+      'imports': self.GetImports()[0],
       'interfaces': self.GetInterfaces(),
-      'package': GetPackageName(self.module),
+      'mojom_imports': self.GetMojomImports(),
+      'package': package,
       'structs': self.GetStructs(),
-      'unions': self.GetUnions(),
+      'descpkg': '%s.' % _service_describer_pkg_short if package != _service_describer_pkg_short else '',
+      'typepkg': '%s.' % _mojom_types_pkg_short if package != _mojom_types_pkg_short else '',
+      'unions': self.GetUnions()
     }
 
   @UseJinja('go_templates/source.tmpl', filters=go_filters)
   def GenerateSource(self):
     return self.GetParameters()
 
   def GenerateFiles(self, args):
     self.Write(self.GenerateSource(), os.path.join("go", "src",
         GetPackagePath(self.module), "%s.go" % self.module.name))
 
   def GetJinjaParameters(self):
     return {
       'lstrip_blocks': True,
       'trim_blocks': True,
     }
 
   def GetGlobals(self):
     return {
       'namespace': self.module.namespace,
       'module': self.module,
     }
 
   # Scans |self.module| for elements that require imports and adds all found
-  # imports to '_imports' dict. Returns a list of imports that should include
-  # the generated go file.
+  # imports to '_imports' dict. Mojom imports are stored in the '_mojom_imports'
+  # dict. This operation is idempotent.
+  # Returns a tuple:
+  # - list of imports that should include the generated go file
+  # - the dictionary of _mojom_imports
   def GetImports(self):
     # Imports can only be used in structs, constants, enums, interfaces.
     all_structs = list(self.module.structs)
     for i in self.module.interfaces:
       for method in i.methods:
         all_structs.append(self._GetStructFromMethod(method))
         if method.response_parameters:
           all_structs.append(self._GetResponseStructFromMethod(method))
 
     if (len(all_structs) > 0 or len(self.module.interfaces) > 0
@@ skipping 14 matching lines @@
         AddImport(self.module, field.kind)
 # TODO(rogulenko): add these after generating constants and struct defaults.
 #        if field.default:
 #          AddImport(self.module, field.default)
 
     for enum in GetAllEnums(self.module):
       for field in enum.fields:
         if field.value:
           AddImport(self.module, field.value)
 
+    num_user_defined_types = len(self.module.interfaces) + \
+      len(self.module.unions) + len(all_structs) + len(GetAllEnums(self.module))
+    if num_user_defined_types > 0 \
+      and GetPackageName(self.module) != _mojom_types_pkg_short:
+        _imports[_mojom_types_pkg] = _mojom_types_pkg_short
+
+    if len(self.module.interfaces) > 0 \
+      and GetPackageName(self.module) != _mojom_types_pkg_short \
+      and GetPackageName(self.module) != _service_describer_pkg_short:
+      _imports[_service_describer_pkg] = _service_describer_pkg_short
+
 # TODO(rogulenko): add these after generating constants and struct defaults.
 #    for constant in GetAllConstants(self.module):
 #      AddImport(self.module, constant.value)
 
     imports_list = []
     for i in _imports:
       if i.split('/')[-1] == _imports[i]:
         imports_list.append('"%s"' % i)
       else:
         imports_list.append('%s "%s"' % (_imports[i], i))
-    return sorted(imports_list)
+    return sorted(imports_list), _mojom_imports
+
+  def GetMojomImports(self):
+    # GetImports (idempotent) prepares the _imports and _mojom_imports maps.
+    return self.GetImports()[1]
 
   # Overrides the implementation from the base class in order to customize the
   # struct and field names.
   def _GetStructFromMethod(self, method):
     params_class = "%s_%s_Params" % (GetNameForElement(method.interface),
         GetNameForElement(method))
     struct = mojom.Struct(params_class, module=method.interface.module)
     for param in method.parameters:
       struct.AddField("in%s" % GetNameForElement(param),
           param.kind, param.ordinal, attributes=param.attributes)
     return self._AddStructComputedData(False, struct)
 
   # Overrides the implementation from the base class in order to customize the
   # struct and field names.
   def _GetResponseStructFromMethod(self, method):
     params_class = "%s_%s_ResponseParams" % (
         GetNameForElement(method.interface), GetNameForElement(method))
     struct = mojom.Struct(params_class, module=method.interface.module)
     for param in method.response_parameters:
       struct.AddField("out%s" % GetNameForElement(param),
           param.kind, param.ordinal, attributes=param.attributes)
     return self._AddStructComputedData(False, struct)