Generate Mojom Types for Dart

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

 # Copyright 2014 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 dart source files from a mojom.Module."""
 
+from collections import defaultdict

[zra, 2015/11/24 17:34:44]

I'm not familiar with python conventions for import order, but this looks a bit
out of place here.

[azani, 2015/11/24 20:02:02]

The prescribed style is that you import the module and then access the module's
content.

So you would switch this to "import collections" and then call
collections.defaultdict

[alexfandrianto, 2015/12/18 01:53:19]

Not needed anymore. No more identifiercache

 import os
 import re
 import shutil
 import sys
 
 import mojom.fileutil as fileutil
 import mojom.generate.constant_resolver as resolver
 import mojom.generate.generator as generator
 import mojom.generate.module as mojom
 import mojom.generate.pack as pack
@@ skipping 46 matching lines @@
   mojom.NULLABLE_DPPIPE:       "core.MojoDataPipeProducer",
   mojom.NULLABLE_MSGPIPE:      "core.MojoMessagePipeEndpoint",
   mojom.NULLABLE_SHAREDBUFFER: "core.MojoSharedBuffer",
   mojom.INT64:                 "int",
   mojom.UINT64:                "int",
   mojom.DOUBLE:                "double",
   mojom.STRING:                "String",
   mojom.NULLABLE_STRING:       "String"
 }
 
+_kind_to_mojom_type = {
+  mojom.BOOL:                  "BOOL",
+  mojom.INT8:                  "INT8",
+  mojom.UINT8:                 "UINT8",
+  mojom.INT16:                 "INT16",
+  mojom.UINT16:                "UINT16",
+  mojom.INT32:                 "INT32",
+  mojom.UINT32:                "UINT32",
+  mojom.FLOAT:                 "FLOAT",
+  mojom.HANDLE:                "UNSPECIFIED",
+  mojom.DCPIPE:                "DATA_PIPE_CONSUMER",
+  mojom.DPPIPE:                "DATA_PIPE_PRODUCER",
+  mojom.MSGPIPE:               "MESSAGE_PIPE",
+  mojom.SHAREDBUFFER:          "SHARED_BUFFER",
+  mojom.NULLABLE_HANDLE:       "UNSPECIFIED",
+  mojom.NULLABLE_DCPIPE:       "DATA_PIPE_CONSUMER",
+  mojom.NULLABLE_DPPIPE:       "DATA_PIPE_PRODUCER",
+  mojom.NULLABLE_MSGPIPE:      "MESSAGE_PIPE",
+  mojom.NULLABLE_SHAREDBUFFER: "SHARED_BUFFER",
+  mojom.INT64:                 "INT64",
+  mojom.UINT64:                "UINT64",
+  mojom.DOUBLE:                "DOUBLE",
+  mojom.STRING:                "STRING",
+  mojom.NULLABLE_STRING:       "STRING"
+}
+
 _spec_to_decode_method = {
   mojom.BOOL.spec:                  'decodeBool',
   mojom.DCPIPE.spec:                'decodeConsumerHandle',
   mojom.DOUBLE.spec:                'decodeDouble',
   mojom.DPPIPE.spec:                'decodeProducerHandle',
   mojom.FLOAT.spec:                 'decodeFloat',
   mojom.HANDLE.spec:                'decodeHandle',
   mojom.INT16.spec:                 'decodeInt16',
   mojom.INT32.spec:                 'decodeInt32',
   mojom.INT64.spec:                 'decodeInt64',
@@ skipping 32 matching lines @@
   mojom.NULLABLE_SHAREDBUFFER.spec: 'encodeSharedBufferHandle',
   mojom.NULLABLE_STRING.spec:       'encodeString',
   mojom.SHAREDBUFFER.spec:          'encodeSharedBufferHandle',
   mojom.STRING.spec:                'encodeString',
   mojom.UINT16.spec:                'encodeUint16',
   mojom.UINT32.spec:                'encodeUint32',
   mojom.UINT64.spec:                'encodeUint64',
   mojom.UINT8.spec:                 'encodeUint8',
 }
 
+# The mojom_types.mojom and service_describer.mojom files are special because

[zra, 2015/11/24 17:34:44]

It looks like you might be trying to avoid importing these libraries where they
aren't needed. If so, that might be good to mention here. If that isn't the
case, then I'm not sure I see why these imports can't be hardcoded into the
template.

[alexfandrianto, 2015/12/18 01:53:19]

Done.

+# they are used to generate mojom Type's and ServiceDescription implementations.
+_service_describer_pkg_short = "service_describer"
+_service_describer_pkg = "package:mojo/mojo/%s.mojom.dart" % \
+  _service_describer_pkg_short
+_mojom_types_pkg_short = "mojom_types"
+_mojom_types_pkg = "package:mojo/mojo/%s.mojom.dart" % \
+  _mojom_types_pkg_short
+
 def GetDartType(kind):
   if kind.imported_from:
     return kind.imported_from["unique_name"] + "." + GetNameForElement(kind)
   return GetNameForElement(kind)
 
 def DartDefaultValue(field):
   if field.default:
     if mojom.IsStructKind(field.kind):
       assert field.default == "default"
       return "new %s()" % GetDartType(field.kind)
@@ skipping 30 matching lines @@
   if mojom.IsMapKind(kind):
     key_type = DartDeclType(kind.key_kind)
     value_type = DartDeclType(kind.value_kind)
     return "Map<"+ key_type + ", " + value_type + ">"
   if mojom.IsInterfaceKind(kind) or \
      mojom.IsInterfaceRequestKind(kind):
     return "Object"
   if mojom.IsEnumKind(kind):
     return GetDartType(kind)
 
+def GetMojomTypeValue(kind, typepkg=''):
+  if not kind in _kind_to_mojom_type:
+    return ''
+
+  nullable = 'true' if mojom.IsNullableKind(kind) else 'false'
+  w = _kind_to_mojom_type[kind]
+  if kind == mojom.BOOL or kind == mojom.FLOAT or kind == mojom.DOUBLE or \
+    mojom.IsIntegralKind(kind):
+
+    return 'new %sType()..simpleType = %sSimpleType.%s' % (typepkg, typepkg, w)
+  elif mojom.IsAnyHandleKind(kind):
+    return ('new %sType()\n..handleType = (new %sHandleType()' +
+      '\n..kind = %sHandleTypeKind.%s' +
+      '\n..nullable = %s)') % \
+      (typepkg, typepkg, typepkg, w, nullable)
+  elif mojom.IsStringKind(kind):
+    return 'new %sType()\n..stringType = (new %sStringType()..nullable = %s)' \
+      % (typepkg, typepkg, nullable)
+  else:
+    raise Exception('Missing case for kind: %s' % kind)
+
 def NameToComponent(name):
   # insert '_' between anything and a Title name (e.g, HTTPEntry2FooBar ->
   # HTTP_Entry2_FooBar)
   name = re.sub('([^_])([A-Z][^A-Z_]+)', r'\1_\2', name)
   # insert '_' between non upper and start of upper blocks (e.g.,
   # HTTP_Entry2_FooBar -> HTTP_Entry2_Foo_Bar)
   name = re.sub('([^A-Z_])([A-Z])', r'\1_\2', name)
   return [x.lower() for x in name.split('_')]
 
 def UpperCamelCase(name):
@@ skipping 190 matching lines @@
 
 def IsPointerArrayKind(kind):
   if not mojom.IsArrayKind(kind):
     return False
   sub_kind = kind.kind
   return mojom.IsObjectKind(sub_kind)
 
 def IsEnumArrayKind(kind):
   return mojom.IsArrayKind(kind) and mojom.IsEnumKind(kind.kind)
 
+def IsImportedKind(kind):
+  return hasattr(kind, 'imported_from') and kind.imported_from
+
 def ParseStringAttribute(attribute):
   assert isinstance(attribute, basestring)
   return attribute
 
 def GetPackage(module):
   if module.attributes and 'DartPackage' in module.attributes:
     return ParseStringAttribute(module.attributes['DartPackage'])
   # Default package.
   return 'mojom'
 
+def GetPackageName(module):
+  return module.name.split('.')[0]
+
 def GetImportUri(module):
   package = GetPackage(module);
   elements = module.namespace.split('.')
   elements.append("%s" % module.name)
   return os.path.join(package, *elements)
 
+# The identifier_store tracks identifiers that have been used so that code

[zra, 2015/11/24 17:34:44]

Is this needed for the new code generation you're adding, or does it fix some
bug in the existing generated code? If it's the latter we should add a
regression test and do this fix in a separate CL.

[alexfandrianto, 2015/12/18 01:53:19]

Removed

+# generation can avoid over-generating code for the same identifier.
+identifier_store = defaultdict(bool)
+def GetIdentifier(kind):
+  # Use the kind's module to determine the package and name.
+  # Note: InterfaceRequestKind's should use the Interface inside them.
+  if hasattr(kind, 'module'):
+    package = GetPackageName(kind.module)
+    name = kind.name
+  elif mojom.IsInterfaceRequestKind(kind):
+    package = GetPackageName(kind.kind.module)
+    name = kind.kind.name
+  else:
+    # This is for a type that should not be stored. Return an empty identifier.
+    return ''
+
+  return '%s_%s' % (package, name)
+
+def StoreIdentifier(identifier):
+  identifier_store[identifier] = True
+  return ''
+
+def CheckIdentifier(identifier):
+  return identifier in identifier_store
+
+def GetMojomTypeIdentifier(kind):
+  """Get the mojom type's identifier suffix."""
+  # Since this should be unique, it is based on the type's identifier.
+  return "_%s__" % GetIdentifier(kind)
+
 class Generator(generator.Generator):
 
   dart_filters = {
     'array_expected_length': GetArrayExpectedLength,
     'array': GetArrayKind,
     'decode_method': DecodeMethod,
     'default_value': DartDefaultValue,
     'encode_method': EncodeMethod,
     'expression_to_text': ExpressionToText,
+    'identifier': GetIdentifier,
+    'identifier_check': CheckIdentifier,
+    'identifier_store': StoreIdentifier,
+    'mojom_type_value': GetMojomTypeValue,
+    'mojom_type_identifier': GetMojomTypeIdentifier,
+    'is_imported_kind': IsImportedKind,
+    'is_array_kind': mojom.IsArrayKind,
     'is_map_kind': mojom.IsMapKind,
     'is_nullable_kind': mojom.IsNullableKind,
     'is_pointer_array_kind': IsPointerArrayKind,
     'is_enum_array_kind': IsEnumArrayKind,
     'is_struct_kind': mojom.IsStructKind,
     'is_union_kind': mojom.IsUnionKind,
     'is_enum_kind': mojom.IsEnumKind,
+    'is_interface_kind': mojom.IsInterfaceKind,
+    'is_interface_request_kind': mojom.IsInterfaceRequestKind,
     'dart_true_false': GetDartTrueFalse,
     'dart_type': DartDeclType,
     'name': GetNameForElement,
     'tag_name': GetUnionFieldTagName,
     'interface_response_name': GetInterfaceResponseName,
     'dot_to_underscore': DotToUnderscore,
     'is_cloneable_kind': mojom.IsCloneableKind,
+    'upper_camel': UpperCamelCase,
   }
 
+  # If set to True, then mojom type information will be generated.
+  should_gen_mojom_types = False
+
   def GetParameters(self, args):
-    return {
+    package = GetPackageName(self.module)
+
+    parameters = {
       "namespace": self.module.namespace,
       "imports": self.GetImports(args),
       "kinds": self.module.kinds,
       "enums": self.module.enums,
       "module": resolver.ResolveConstants(self.module, ExpressionToText),
       "structs": self.GetStructs() + self.GetStructsFromMethods(),
       "unions": self.GetUnions(),
       "interfaces": self.GetInterfaces(),
       "imported_interfaces": self.GetImportedInterfaces(),
       "imported_from": self.ImportedFrom(),
+      "typepkg": '%s.' % _mojom_types_pkg_short,
+      "descpkg": '%s.' % _service_describer_pkg_short,
+      "mojom_types_import": 'import \'%s\' as %s;' % \
+        (_mojom_types_pkg, _mojom_types_pkg_short),
+      "service_describer_import": 'import \'%s\' as %s;' % \
+        (_service_describer_pkg, _service_describer_pkg_short),
+    }
+
+    # If this is the mojom types package, clear the import-related params.
+    if package == _mojom_types_pkg_short:
+      parameters["typepkg"] = ""
+      parameters["mojom_types_import"] = ""
+
+    # If this is the service describer package, clear the import-related params.
+    if package == _service_describer_pkg_short:
+      parameters["descpkg"] = ""
+      parameters["service_describer_import"] = ""
+
+    # If no interfaces were defined, the service describer import isn't needed.
+    if len(self.module.interfaces) == 0:
+      parameters["service_describer_import"] = ""
+
+    return parameters
+
+  def GetGlobals(self):
+    return {
+      'should_gen_mojom_types': self.should_gen_mojom_types,
     }
 
   @UseJinja("dart_templates/module.lib.tmpl", filters=dart_filters)
   def GenerateLibModule(self, args):
     return self.GetParameters(args)
 
 
   def GenerateFiles(self, args):
+    if "--dart_gen_types" in args:
+      self.should_gen_mojom_types = True
+
     elements = self.module.namespace.split('.')
     elements.append("%s.dart" % self.module.name)
 
     lib_module = self.GenerateLibModule(args)
 
     # List of packages with checked in bindings.
     # TODO(johnmccutchan): Stop generating bindings as part of build system
     # and then remove this.
     packages_with_checked_in_bindings = [
       '_mojo_for_test_only',
@@ skipping 57 matching lines @@
         interface_to_import[name] = each_import["unique_name"] + "." + name
     return interface_to_import
 
   def ImportedFrom(self):
     interface_to_import = {}
     for each_import in self.module.imports:
       for each_interface in each_import["module"].interfaces:
         name = each_interface.name
         interface_to_import[name] = each_import["unique_name"] + "."
     return interface_to_import