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'):

[qsr, 2014/07/16 09:08:38]

What would happen for enum value >= 2**31?
Or is it disallowed?

[Sam McNally, 2014/07/16 09:38:49]

I expect they would be treated the same as uint32 values >= 2**31. Enum values
>= 2**32 seem to break C++ compile so I guess those are disallowed.

+    # Add Long suffix to all integer literals.
+    try:
+      number = ast.literal_eval(token)
+    except ValueError:

[qsr, 2014/07/16 09:08:38]

Hum... You need this when an integer reference a constant or something like
this, don't you? Does this mean we should get more information here instead of
relying on an exception?

[Sam McNally, 2014/07/16 09:38:49]

References to other constants or enum values are handled by the NamedValue case
above. This was just in case values that Python doesn't like as literals are
allowed, but upon further inspection the only problem cases are leading pluses
and spaces.

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

 Thanks.

+      return token
+    if not isinstance(number, (int, long)):
+      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,
     }