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."""
 
 import os
 import re
 import shutil
 import sys
@@ skipping 52 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
+# 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 is not None
+
 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)
 
+identifier_cache = {}
+def GetIdentifier(kind):
+  # Use the kind's module to determine the package name.
+  if hasattr(kind, 'module'):
+    package = GetPackageName(kind.module)
+  elif mojom.IsInterfaceRequestKind(kind):
+    package = GetPackageName(kind.kind.module)
+  else:
+    return ''
+
+  # 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.
+  name_or_spec = (kind.name if hasattr(kind, 'name') else kind.spec)
+  package_unique = name_or_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):
+  # 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,
   }
 
+  # TODO: This value should be settable via arguments. If False, then mojom type
+  # information will not be generated.
+  should_gen_mojom_types = True
+
   def GetParameters(self, args):
+    package = GetPackageName(self.module)
+    defInterface = len(self.module.interfaces) > 0
+
     return {
       "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 \
+        if package != _mojom_types_pkg_short else '',
+      "descpkg": '%s.' % _service_describer_pkg_short \
+        if package != _service_describer_pkg_short else '',
+      "mojom_types_import": 'import \'%s\' as %s;' % \
+        (_mojom_types_pkg, _mojom_types_pkg_short) \
+        if package != _mojom_types_pkg_short else '',
+      "service_describer_import": 'import \'%s\' as %s;' % \
+        (_service_describer_pkg, _service_describer_pkg_short) \
+        if defInterface and package != _service_describer_pkg_short else '',
+    }
+
+  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):
     elements = self.module.namespace.split('.')
     elements.append("%s.dart" % self.module.name)
@@ skipping 52 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