Mojo: Always suffix int literals with L in generated Java bindings.

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
 
 
@@ skipping 183 matching lines @@
 
 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))
+  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):
     return NewArray(context, kind.kind, size) + '[]'
   return 'new %s[%s]' % (GetJavaType(context, kind.kind), size)
 
 @contextfilter
-def ExpressionToText(context, token):
+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:
     if not isinstance(named_value, mojom.EnumValue):
       entity_name = (GetConstantsMainEntityName(named_value.module) + '.' +
                       entity_name)
     if GetPackage(named_value.module) == GetPackage(context.resolve('module')):
       return entity_name
     return GetPackage(named_value.module) + '.' + entity_name
 
   if isinstance(token, mojom.NamedValue):
     return _TranslateNamedValue(token)
-  # Add Long suffix to all number literals.
-  if re.match('^[0-9]+$', token):
-    number = int(token)
+  if kind_spec.startswith('i') or kind_spec.startswith('u'):
+    # Add Long suffix to all integer literals.
+    number = ast.literal_eval(token.lstrip('+ '))
+    if not isinstance(number, (int, long)):

[qsr, 2014/07/16 09:41:36]

Should you just raise here? What is the legit case that goes here?

[Sam McNally, 2014/07/16 09:51:30]

Done.

+      return 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):
     return False
   sub_kind = kind.kind
   return generator.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_pointer_array_kind": IsPointerArrayKind,
     "is_struct_kind": lambda kind: isinstance(kind, mojom.Struct),
     "java_type": GetJavaType,
     "name": GetNameForElement,
     "new_array": NewArray,
@@ skipping 68 matching lines @@
   def GetJinjaParameters(self):
     return {
       'lstrip_blocks': True,
       'trim_blocks': True,
     }
 
   def GetGlobals(self):
     return {
       'module': self.module,
     }