Generate Mojom Types in Dart (Take 2)

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."""
 
 import errno
 import os
 import re
 import shutil
@@ skipping 105 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:                "dataPipeConsumer",
+  mojom.DPPIPE:                "dataPipeProducer",
+  mojom.MSGPIPE:               "messagePipe",
+  mojom.SHAREDBUFFER:          "sharedBuffer",
+  mojom.NULLABLE_HANDLE:       "unspecified",
+  mojom.NULLABLE_DCPIPE:       "dataPipeConsumer",
+  mojom.NULLABLE_DPPIPE:       "dataPipeProducer",
+  mojom.NULLABLE_MSGPIPE:      "messagePipe",
+  mojom.NULLABLE_SHAREDBUFFER: "sharedBuffer",
+  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
+# they are used to generate mojom Type's and ServiceDescription implementations.
+# They need to be imported, unless the file itself is being generated.
+_service_describer_pkg_short = "service_describer"
+_service_describer_pkg = "package:mojo/mojo/bindings/types/%s.mojom.dart" % \
+  _service_describer_pkg_short
+_mojom_types_pkg_short = "mojom_types"
+_mojom_types_pkg = "package:mojo/mojo/bindings/types/%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=''):

[zra, 2016/01/15 21:01:33]

I think it would be more consistent to move this logic to a template macro.

[alexfandrianto, 2016/01/20 00:08:28]

Pretty much all the languages use a map for the simple/handle/string kinds, so
the inconsistency must be the string concatenations.

It really takes a lot longer code-wise if I remove the map and need to add more
filters, so I've moved as much of it over as I can without making it overly
painful.

+  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). Numbers terminate a string of lower-case characters.
   name = re.sub('([^_])([A-Z][^A-Z1-9_]+)', 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 181 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)
 
+def GetIdentifier(kind):

[zra, 2016/01/15 21:01:33]

This name is too generic for what (I think) this function does. The name
generation functions that you're adding should be made more distinct from e.g.
GetNameForElement. There should be no confusion about which one should be used
when the next person comes along to add a feature.

Also, unless the names generated here have some significance outside of Dart,
they should probably use GetNameForElement to make names with Dart styling.

[alexfandrianto, 2016/01/20 00:08:28]

This was combined with GetMojomTypeIdentifier below. This is used to uniquely
identify mojom types across languages.

+  """Use the kind's module to determine the package and name."""
+  # Note: InterfaceRequest'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:
+    # These kinds (e.g., simple kinds, maps, and arrays) lack identifiers.
+    raise Exception('Unexpected kind: %s' % kind)
+
+  return '%s_%s' % (package, name)
+
+# Returns a string of the form package.path.TypeName - the full identifier
+# for an element.
+def GetFullIdentifier(element, exported=True):
+  return '%s.%s' % (element.module.namespace, GetNameForElement(element))
+
+def RaiseHelper(msg):
+    raise Exception(msg)
+
+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)

[zra, 2016/01/15 21:01:33]

Why are there trailing underscores?

[alexfandrianto, 2016/01/20 00:08:28]

This has to match between languages, and the Go one already has trailing
underscores.

+
 class Generator(generator.Generator):
 
   dart_filters = {
     'array_expected_length': GetArrayExpectedLength,
     'array': GetArrayKind,
     'decode_method': DecodeMethod,
     'default_value': DartDefaultValue,
     'encode_method': EncodeMethod,
+    'fullidentifier': GetFullIdentifier,
+    'identifier': GetIdentifier,
+    '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,
     'interface_response_name': GetInterfaceResponseName,
     'dot_to_underscore': DotToUnderscore,
     'is_cloneable_kind': mojom.IsCloneableKind,
+    'upper_camel': UpperCamelCase,
+    'raise': RaiseHelper,
   }
 
+  # 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):
+    self.should_gen_mojom_types = "--generate_type_info" in args
+
     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 63 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