Mojom runtime type info: New implementation for 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 os
 import re
 
@@ skipping 175 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 ''
-
-  nullable = 'true' if mojom.IsNullableKind(kind) else 'false'
-  if kind == mojom.BOOL or kind == mojom.FLOAT or kind == mojom.DOUBLE or \
-    mojom.IsIntegralKind(kind):
-
-    kind_name = UpperCamelCase(_kind_infos[kind].decode_suffix.upper())
-    if kind == mojom.FLOAT:
-      kind_name = "Float"
-    elif kind == mojom.DOUBLE:
-      kind_name = "Double"
-    return '%sTypeSimpleType{%sSimpleType_%s}' % (typepkg, typepkg, kind_name)
-  elif mojom.IsAnyHandleKind(kind):
-    kind_name = 'Unspecified'
-    if kind == mojom.DCPIPE:
-      kind_name = 'DataPipeConsumer'
-    elif kind == mojom.DPPIPE:
-      kind_name = 'DataPipeProducer'
-    elif kind == mojom.MSGPIPE:
-      kind_name = 'MessagePipe'
-    elif kind == mojom.SHAREDBUFFER:
-      kind_name = 'SharedBuffer'
-    return '%sTypeHandleType{%sHandleType{' \
-      'Nullable: %s, Kind: %sHandleType_Kind_%s}}' % \
-      (typepkg, typepkg, nullable, typepkg, kind_name)
-  elif mojom.IsStringKind(kind):
-    return '%sTypeStringType{%sStringType{%s}}' % (typepkg, typepkg, nullable)
-  else:
-    raise Exception('Missing case for kind: %s' % kind)
-
 def GetPackageName(module):
   return module.name.split('.')[0]
 
 def GetPackageNameForElement(element):
   if not hasattr(element, 'imported_from') or not element.imported_from:
     return ''
   return element.imported_from.get('go_name', '')
 
+def GetTypeKeyForElement(element):
+  if not hasattr(element, 'type_key') or not element.type_key:
+    return ''
+  return element.type_key
+
 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)]
 
+def GetSerializedRuntimeTypeInfoLiteral(module, enabled):
+  """ Constructs a string that represents a literal definition in Go of
+  an array of bytes corresponding to |module.serialized_runtime_type_info|.
+
+  Args:
+    module: {mojom.Module} the module being processed.
+    enabled: {bool} Is this feature enabled.
+
+  Returns: A string of the form '{b0, b1, b2,...}' where the 'bi' are
+  the decimal representation of the bytes of
+  |module.serialized_runtime_type_info| or the string '{}' if either
+  |enabled| is false or |module.serialized_runtime_type_info| is None.
+  Furthermore the returned string will have embedded newline characters inserted
+  every 1000 characters to make the generated source code more tractable.
+  """
+  if not enabled or not module.serialized_runtime_type_info:
+    return '{}'
+  return '{%s}' % ','.join('%s%d' %
+      ('\n' if index > 0 and index%1000 == 0 else '', b)
+          for index, b in enumerate(module.serialized_runtime_type_info))
+
 def AddImport(imports, mojom_imports, module, element):
   """Adds an import required to use the provided element.
 
   The required import is stored in the imports parameter.
   The corresponding mojom import is stored in the mojom_imports parameter.
   Each import is also updated to include a 'go_name' entry. The 'go_name' entry
   is the name by which the imported module will be referred to in the generated
   code. Because the import dictionary is accessible from the element's
   imported_from field this allows us to generate the qualified name for the
   element.
@@ skipping 50 matching lines @@
     '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,
-    'fullidentifier': mojom.GetMojomTypeFullIdentifier,
-    'mojom_type': GetMojomTypeValue,
-    'mojom_type_identifier': mojom.GetMojomTypeIdentifier,
+    'mojom_type_key' : GetTypeKeyForElement,
     'name': GetNameForElement,
     'unqualified_name': GetUnqualifiedNameForElement,
     'package': GetPackageNameForElement,
     'tab_indent': lambda s, size = 1: ('\n' + '\t' * size).join(s.splitlines())
   }
 
   # If set to True, then mojom type information will be generated.
   should_gen_mojom_types = False
 
   def GetParameters(self):
     package = GetPackageName(self.module)
     imports, mojom_imports = self.GetImports()
     return {
       'enums': GetAllEnums(self.module),
       'imports': imports,
       'interfaces': self.GetInterfaces(),
       'mojom_imports': mojom_imports,
       'package': package,
       'structs': self.GetStructs(),
       '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()
+      'unions': self.GetUnions(),
+      'serialized_runtime_type_info_literal' : (
+          GetSerializedRuntimeTypeInfoLiteral(self.module,
+              self.should_gen_mojom_types))
     }
 
   @UseJinja('go_templates/source.tmpl', filters=go_filters)
   def GenerateSource(self):
     return self.GetParameters()
 
   def GenerateFiles(self, args):
     self.should_gen_mojom_types = "--generate_type_info" in args
 
     self.Write(self.GenerateSource(), os.path.join("go", "src",
@@ skipping 97 matching lines @@
   # 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)