Mojom generator: move Is.*Kind() functions into module.py and use them from all mojom_.*_generator.…

mojo/public/tools/bindings/generators/mojom_java_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 java source files from a mojom.Module."""
 
 import argparse
 import ast
 import os
 import re
 
 from jinja2 import contextfilter
 
 import mojom.generate.generator as generator
 import mojom.generate.module as mojom
 from mojom.generate.template_expander import UseJinja
 
 
 GENERATOR_PREFIX = 'java'
 
 _HEADER_SIZE = 8
 
 _spec_to_java_type = {
-  'b':     'boolean',
-  'd':     'double',
-  'f':     'float',
-  'h:d:c': 'org.chromium.mojo.system.DataPipe.ConsumerHandle',
-  'h:d:p': 'org.chromium.mojo.system.DataPipe.ProducerHandle',
-  'h:m':   'org.chromium.mojo.system.MessagePipeHandle',
-  'h':     'org.chromium.mojo.system.UntypedHandle',
-  'h:s':   'org.chromium.mojo.system.SharedBufferHandle',
-  'i16':   'short',
-  'i32':   'int',
-  'i64':   'long',
-  'i8':    'byte',
-  's':     'String',
-  'u16':   'short',
-  'u32':   'int',
-  'u64':   'long',
-  'u8':    'byte',
+  mojom.BOOL.spec: 'boolean',
+  mojom.DCPIPE.spec: 'org.chromium.mojo.system.DataPipe.ConsumerHandle',
+  mojom.DOUBLE.spec: 'double',
+  mojom.DPPIPE.spec: 'org.chromium.mojo.system.DataPipe.ProducerHandle',
+  mojom.FLOAT.spec: 'float',
+  mojom.HANDLE.spec: 'org.chromium.mojo.system.UntypedHandle',
+  mojom.INT16.spec: 'short',
+  mojom.INT32.spec: 'int',
+  mojom.INT64.spec: 'long',
+  mojom.INT8.spec: 'byte',
+  mojom.MSGPIPE.spec: 'org.chromium.mojo.system.MessagePipeHandle',
+  mojom.NULLABLE_DCPIPE.spec:
+      'org.chromium.mojo.system.DataPipe.ConsumerHandle',
+  mojom.NULLABLE_DPPIPE.spec:
+      'org.chromium.mojo.system.DataPipe.ProducerHandle',
+  mojom.NULLABLE_HANDLE.spec: 'org.chromium.mojo.system.UntypedHandle',
+  mojom.NULLABLE_MSGPIPE.spec: 'org.chromium.mojo.system.MessagePipeHandle',
+  mojom.NULLABLE_SHAREDBUFFER.spec:
+      'org.chromium.mojo.system.SharedBufferHandle',
+  mojom.NULLABLE_STRING.spec: 'String',
+  mojom.SHAREDBUFFER.spec: 'org.chromium.mojo.system.SharedBufferHandle',
+  mojom.STRING.spec: 'String',
+  mojom.UINT16.spec: 'short',
+  mojom.UINT32.spec: 'int',
+  mojom.UINT64.spec: 'long',
+  mojom.UINT8.spec: 'byte',
 }
 
 _spec_to_decode_method = {
-  'b':     'readBoolean',
-  'd':     'readDouble',
-  'f':     'readFloat',
-  'h:d:c': 'readConsumerHandle',
-  'h:d:p': 'readProducerHandle',
-  'h:m':   'readMessagePipeHandle',
-  'h':     'readUntypedHandle',
-  'h:s':   'readSharedBufferHandle',
-  'i16':   'readShort',
-  'i32':   'readInt',
-  'i64':   'readLong',
-  'i8':    'readByte',
-  's':     'readString',
-  'u16':   'readShort',
-  'u32':   'readInt',
-  'u64':   'readLong',
-  'u8':    'readByte',
+  mojom.BOOL.spec:                  'readBoolean',
+  mojom.DCPIPE.spec:                'readConsumerHandle',
+  mojom.DOUBLE.spec:                'readDouble',
+  mojom.DPPIPE.spec:                'readProducerHandle',
+  mojom.FLOAT.spec:                 'readFloat',
+  mojom.HANDLE.spec:                'readUntypedHandle',
+  mojom.INT16.spec:                 'readShort',
+  mojom.INT32.spec:                 'readInt',
+  mojom.INT64.spec:                 'readLong',
+  mojom.INT8.spec:                  'readByte',
+  mojom.MSGPIPE.spec:               'readMessagePipeHandle',
+  mojom.NULLABLE_DCPIPE.spec:       'readConsumerHandle',
+  mojom.NULLABLE_DPPIPE.spec:       'readProducerHandle',
+  mojom.NULLABLE_HANDLE.spec:       'readUntypedHandle',
+  mojom.NULLABLE_MSGPIPE.spec:      'readMessagePipeHandle',
+  mojom.NULLABLE_SHAREDBUFFER.spec: 'readSharedBufferHandle',
+  mojom.NULLABLE_STRING.spec:       'readString',
+  mojom.SHAREDBUFFER.spec:          'readSharedBufferHandle',
+  mojom.STRING.spec:                'readString',
+  mojom.UINT16.spec:                'readShort',
+  mojom.UINT32.spec:                'readInt',
+  mojom.UINT64.spec:                'readLong',
+  mojom.UINT8.spec:                 'readByte',
 }
 
 _java_primitive_to_boxed_type = {
   'boolean': 'Boolean',
   'byte':    'Byte',
   'double':  'Double',
   'float':   'Float',
   'int':     'Integer',
   'long':    'Long',
   'short':   'Short',
@@ skipping 19 matching lines @@
   uccc = UpperCamelCase(name)
   return uccc[0].lower() + uccc[1:]
 
 def ConstantStyle(name):
   components = NameToComponent(name)
   if components[0] == 'k':
     components = components[1:]
   return '_'.join([x.upper() for x in components])
 
 def GetNameForElement(element):
-  if isinstance(element, (mojom.Enum,
-                          mojom.Interface,
-                          mojom.Struct)):
+  if (mojom.IsEnumKind(element) or mojom.IsInterfaceKind(element) or
+      mojom.IsStructKind(element)):
     return UpperCamelCase(element.name)
-  if isinstance(element, mojom.InterfaceRequest):
+  if mojom.IsInterfaceRequestKind(element):
     return GetNameForElement(element.kind)
   if isinstance(element, (mojom.Method,
                           mojom.Parameter,
                           mojom.Field)):
     return CamelCase(element.name)
   if isinstance(element,  mojom.EnumValue):
     return (UpperCamelCase(element.enum_name) + '.' +
             ConstantStyle(element.name))
   if isinstance(element, (mojom.NamedValue,
                           mojom.Constant)):
     return ConstantStyle(element.name)
   raise Exception("Unexpected element: " % element)
 
 def GetInterfaceResponseName(method):
   return UpperCamelCase(method.name + 'Response')
 
 def ParseStringAttribute(attribute):
   assert isinstance(attribute, basestring)
   return attribute
 
-def IsArray(kind):
-  return isinstance(kind, (mojom.Array, mojom.FixedArray))
-
 @contextfilter
 def DecodeMethod(context, kind, offset, bit):
   def _DecodeMethodName(kind):
-    if IsArray(kind):
+    if mojom.IsAnyArrayKind(kind):
       return _DecodeMethodName(kind.kind) + 's'
-    if isinstance(kind, mojom.Enum):
+    if mojom.IsEnumKind(kind):
       return _DecodeMethodName(mojom.INT32)
-    if isinstance(kind, mojom.InterfaceRequest):
+    if mojom.IsInterfaceRequestKind(kind):
       return "readInterfaceRequest"
-    if isinstance(kind, mojom.Interface):
+    if mojom.IsInterfaceKind(kind):
       return "readServiceInterface"
     return _spec_to_decode_method[kind.spec]
   methodName = _DecodeMethodName(kind)
   additionalParams = ''
   if (kind == mojom.BOOL):
     additionalParams = ', %d' % bit
-  if isinstance(kind, mojom.Interface):
+  if mojom.IsInterfaceKind(kind):
     additionalParams = ', %s.BUILDER' % GetJavaType(context, kind)
-  if IsArray(kind) and isinstance(kind.kind, mojom.Interface):
+  if mojom.IsAnyArrayKind(kind) and mojom.IsInterfaceKind(kind.kind):
     additionalParams = ', %s.BUILDER' % GetJavaType(context, kind.kind)
   return '%s(%s%s)' % (methodName, offset, additionalParams)
 
 @contextfilter
 def EncodeMethod(context, kind, variable, offset, bit):
   additionalParams = ''
   if (kind == mojom.BOOL):
     additionalParams = ', %d' % bit
-  if isinstance(kind, mojom.Interface):
+  if mojom.IsInterfaceKind(kind):
     additionalParams = ', %s.BUILDER' % GetJavaType(context, kind)
-  if IsArray(kind) and isinstance(kind.kind, mojom.Interface):
+  if mojom.IsAnyArrayKind(kind) and mojom.IsInterfaceKind(kind.kind):
     additionalParams = ', %s.BUILDER' % GetJavaType(context, kind.kind)
   return 'encode(%s, %s%s)' % (variable, offset, additionalParams)
 
 def GetPackage(module):
   if 'JavaPackage' in module.attributes:
     return ParseStringAttribute(module.attributes['JavaPackage'])
   # Default package.
   return "org.chromium.mojom." + module.namespace
 
 def GetNameForKind(context, kind):
@@ skipping 14 matching lines @@
 def GetBoxedJavaType(context, kind):
   unboxed_type = GetJavaType(context, kind, False)
   if unboxed_type in _java_primitive_to_boxed_type:
     return _java_primitive_to_boxed_type[unboxed_type]
   return unboxed_type
 
 @contextfilter
 def GetJavaType(context, kind, boxed=False):
   if boxed:
     return GetBoxedJavaType(context, kind)
-  if isinstance(kind, (mojom.Struct, mojom.Interface)):
+  if mojom.IsStructKind(kind) or mojom.IsInterfaceKind(kind):
     return GetNameForKind(context, kind)
-  if isinstance(kind, mojom.InterfaceRequest):
+  if mojom.IsInterfaceRequestKind(kind):
     return ("org.chromium.mojo.bindings.InterfaceRequest<%s>" %
             GetNameForKind(context, kind.kind))
-  if IsArray(kind):
+  if mojom.IsAnyArrayKind(kind):
     return "%s[]" % GetJavaType(context, kind.kind)
-  if isinstance(kind, mojom.Enum):
+  if mojom.IsEnumKind(kind):
     return "int"
   return _spec_to_java_type[kind.spec]
 
 def IsHandle(kind):
   return kind.spec[0] == 'h'
 
 @contextfilter
 def DefaultValue(context, field):
   assert field.default
   if isinstance(field.kind, mojom.Struct):
     assert field.default == "default"
     return "new %s()" % GetJavaType(context, field.kind)
   return "(%s) %s" % (
       GetJavaType(context, field.kind),
       ExpressionToText(context, field.default, kind_spec=field.kind.spec))
 
 @contextfilter
 def ConstantValue(context, constant):
   return "(%s) %s" % (
       GetJavaType(context, constant.kind),
       ExpressionToText(context, constant.value, kind_spec=constant.kind.spec))
 
 @contextfilter
 def NewArray(context, kind, size):
-  if IsArray(kind.kind):
+  if mojom.IsAnyArrayKind(kind.kind):
     return NewArray(context, kind.kind, size) + '[]'
   return 'new %s[%s]' % (GetJavaType(context, kind.kind), size)
 
 @contextfilter
 def ExpressionToText(context, token, kind_spec=''):
   def _TranslateNamedValue(named_value):
     entity_name = GetNameForElement(named_value)
     if named_value.parent_kind:
       return GetJavaType(context, named_value.parent_kind) + '.' + entity_name
     # Handle the case where named_value is a module level constant:
@@ skipping 13 matching lines @@
       raise ValueError('got unexpected type %r for int literal %r' % (
           type(number), token))
     # If the literal is too large to fit a signed long, convert it to the
     # equivalent signed long.
     if number >= 2 ** 63:
       number -= 2 ** 64
     return '%dL' % number
   return token
 
 def IsPointerArrayKind(kind):
-  if not IsArray(kind):
+  if not mojom.IsAnyArrayKind(kind):
     return False
   sub_kind = kind.kind
-  return generator.IsObjectKind(sub_kind)
+  return mojom.IsObjectKind(sub_kind)
 
 def GetConstantsMainEntityName(module):
   if 'JavaConstantsClassName' in module.attributes:
     return ParseStringAttribute(module.attributes['JavaConstantsClassName'])
   # This constructs the name of the embedding classes for module level constants
   # by extracting the mojom's filename and prepending it to Constants.
   return (UpperCamelCase(module.path.split('/')[-1].rsplit('.', 1)[0]) +
           'Constants')
 
 class Generator(generator.Generator):
 
   java_filters = {
     "interface_response_name": GetInterfaceResponseName,
     "constant_value": ConstantValue,
     "default_value": DefaultValue,
     "decode_method": DecodeMethod,
     "expression_to_text": ExpressionToText,
     "encode_method": EncodeMethod,
-    "is_handle": IsHandle,
+    "is_handle": mojom.IsAnyHandleKind,
     "is_pointer_array_kind": IsPointerArrayKind,
-    "is_struct_kind": lambda kind: isinstance(kind, mojom.Struct),
+    "is_struct_kind": mojom.IsStructKind,
     "java_type": GetJavaType,
     "name": GetNameForElement,
     "new_array": NewArray,
     "struct_size": lambda ps: ps.GetTotalSize() + _HEADER_SIZE,
   }
 
   def GetJinjaExports(self):
     return {
       "module": self.module,
       "package": GetPackage(self.module),
@@ skipping 61 matching lines @@
   def GetJinjaParameters(self):
     return {
       'lstrip_blocks': True,
       'trim_blocks': True,
     }
 
   def GetGlobals(self):
     return {
       'module': self.module,
     }