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"
+}
+
 _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 GetSimpleMojomTypeName(kind):
+  if not kind in _kind_to_mojom_type:
+    raise Exception('Missing case for kind: %s' % kind)
+  return _kind_to_mojom_type[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)
 
+# Returns a string of the form package.path.TypeName - the full identifier

[azani, 2016/01/26 00:29:23]

Can you make that a docstring?

+# for an element.
+def GetFullIdentifier(element, exported=True):
+  return '%s.%s' % (element.module.namespace, GetNameForElementUnsafe(element))
+
+def RaiseHelper(msg):
+    raise Exception(msg)
+
+def GetMojomTypeIdentifier(kind):
+  """Get the mojom type's unique identifier from the kind's 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)
+
 class Generator(generator.Generator):
 
   dart_filters = {
     'array_expected_length': GetArrayExpectedLength,
     'array': GetArrayKind,
     'decode_method': DecodeMethod,
     'default_value': DartDefaultValue,
     'encode_method': EncodeMethod,
+    'fullidentifier': GetFullIdentifier,
+    'simple_mojom_type_name': GetSimpleMojomTypeName,
+    'mojom_type_identifier': GetMojomTypeIdentifier,
+    'is_imported_kind': IsImportedKind,
+    'is_array_kind': mojom.IsArrayKind,
     'is_map_kind': mojom.IsMapKind,
+    'is_numerical_kind': mojom.IsNumericalKind,
+    'is_any_handle_kind': mojom.IsAnyHandleKind,
+    'is_string_kind': mojom.IsStringKind,
     '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,
+    'name_unsafe': GetNameForElementUnsafe,

[azani, 2016/01/26 00:29:23]

Could you name this something that expresses the fact that this is related to
dynamic types generation? Also, maybe fact that into a separate module so it can
be used by other languages too.

     'interface_response_name': GetInterfaceResponseName,
     'dot_to_underscore': DotToUnderscore,
     'is_cloneable_kind': mojom.IsCloneableKind,
+    'upper_camel': UpperCamelCase,
+    'lower_camel': CamelCase,
+    '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