Add constants and primitive type readonly attributes to Python IDL compiler

Source/bindings/scripts/code_generator_v8.py

 # Copyright (C) 2013 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 27 matching lines @@
 import sys
 
 # jinja2 is in chromium's third_party directory.
 module_path, module_name = os.path.split(__file__)
 third_party = os.path.join(module_path, os.pardir, os.pardir, os.pardir, os.pardir)
 sys.path.append(third_party)
 import jinja2
 
 templates_dir = os.path.join(module_path, os.pardir, 'templates')
 
+ACRONYMS = ['CSS', 'HTML', 'IME', 'JS', 'SVG', 'URL', 'XML', 'XSLT']
 CALLBACK_INTERFACE_CPP_INCLUDES = set([
     'core/dom/ScriptExecutionContext.h',
     'bindings/v8/V8Binding.h',
     'bindings/v8/V8Callback.h',
     'wtf/Assertions.h',
 ])
-
-
 CALLBACK_INTERFACE_H_INCLUDES = set([
     'bindings/v8/ActiveDOMCallback.h',
     'bindings/v8/DOMWrapperWorld.h',
     'bindings/v8/ScopedPersistent.h',
 ])
-
-
 INTERFACE_CPP_INCLUDES = set([
     'RuntimeEnabledFeatures.h',
     'bindings/v8/ScriptController.h',
     'bindings/v8/V8Binding.h',
-    'bindings/v8/V8DOMConfiguration.h',
-    'bindings/v8/V8DOMWrapper.h',
+    'bindings/v8/V8DOMConfiguration.h',  # FIXME: necessary?
+    'bindings/v8/V8DOMWrapper.h',  # FIXME: necessary?
     'core/dom/ContextFeatures.h',
     'core/dom/Document.h',
     'core/page/Frame.h',
     'core/platform/chromium/TraceEvent.h',
     'wtf/UnusedParam.h',
 ])
-
-
 INTERFACE_H_INCLUDES = set([
     'bindings/v8/V8Binding.h',
-    'bindings/v8/V8DOMWrapper.h',
-    'bindings/v8/WrapperTypeInfo.h',
+    'bindings/v8/V8DOMWrapper.h',  # FIXME: necessary?
+    'bindings/v8/WrapperTypeInfo.h',  # FIXME: necessary?
 ])
-
-
 CPP_TYPE_SPECIAL_CONVERSION_RULES = {
     'float': 'float',
     'double': 'double',
     'long long': 'long long',
     'unsigned long long': 'unsigned long long',
     'long': 'int',
     'short': 'int',
     'byte': 'int',
     'boolean': 'bool',
     'DOMString': 'const String&',
 }
-
-
+CPP_UNSIGNED_TYPES = set([
+    'octet',
+    'unsigned int',
+    'unsigned long',
+    'unsigned short',
+])
 PRIMITIVE_TYPES = set([
     'boolean',
     'void',
     'Date',
     'byte',
     'octet',
     'short',
     'long',
     'long long',
     'unsigned short',
     'unsigned long',
     'unsigned long long',
     'float',
     'double',
 ])
+V8_SET_RETURN_VALUE_DICT = {
+    'unsigned': 'v8SetReturnValueUnsigned({callback_info}, {cpp_value});',
+}
 
 
 def apply_template(basename, contents):
     jinja_env = jinja2.Environment(trim_blocks=True, loader=jinja2.FileSystemLoader(templates_dir))
     template = jinja_env.get_template(basename)
     return template.render(contents)
 
 
-def cpp_value_to_js_value(data_type, cpp_value, isolate, creation_context=''):
-    """Returns a expression that represent JS value corresponding to a C++ value."""
+def cpp_value_to_v8_value(data_type, cpp_value, isolate, creation_context=''):
+    """Return an expression converting a C++ value to a V8 value."""
     if data_type == 'boolean':
         return 'v8Boolean(%s, %s)' % (cpp_value, isolate)
     if data_type in ['long long', 'unsigned long long', 'DOMTimeStamp']:
         # long long and unsigned long long are not representable in ECMAScript.
         return 'v8::Number::New(static_cast<double>(%s))' % cpp_value
     if primitive_type(data_type):
         if data_type not in ['float', 'double']:
             raise Exception('unexpected data_type %s' % data_type)
         return 'v8::Number::New(%s)' % cpp_value
     if data_type == 'DOMString':
         return 'v8String(%s, %s)' % (cpp_value, isolate)
     if array_or_sequence_type(data_type):
         return 'v8Array(%s, %s)' % (cpp_value, isolate)
     return 'toV8(%s, %s, %s)' % (cpp_value, creation_context, isolate)
 
 
+def v8_set_return_value(data_type, cpp_value, callback_info=''):
+    """Return an statement converting a C++ value to a V8 value and setting it as a return value."""
+    this_cpp_type = cpp_type(data_type)
+    if this_cpp_type in V8_SET_RETURN_VALUE_DICT:
+        expression_format_string = V8_SET_RETURN_VALUE_DICT[this_cpp_type]

[haraken, 2013/08/26 09:33:40]

You can just write:

  return
V8_SET_RETURN_VALUE_DICT[this_cpp_type].format(callback_info=callback_info,
cpp_value=cpp_value)

?

[Nils Barth (inactive), 2013/08/27 02:59:27]

That would be simpler now (with only one case), but when we support more cases,
they'll each have their own format string, so it's easier to do all the filling
in at the end.
...and adding more types (to attributes) is what I'm planning to do next!

You can see in the WIP:
https://codereview.chromium.org/17572008/diff/181001/Source/bindings/scripts/...

+    else:
+        raise Exception('unexpected data_type %s' % data_type)
+    return expression_format_string.format(callback_info=callback_info, cpp_value=cpp_value)
+
+
 def generate_conditional_string(interface_or_attribute_or_operation):
     if 'Conditional' not in interface_or_attribute_or_operation.extended_attributes:
         return ''
     conditional = interface_or_attribute_or_operation.extended_attributes['Conditional']
     for operator in ['&', '|']:
         if operator in conditional:
             conditions = set(conditional.split(operator))
             operator_separator = ' %s%s ' % (operator, operator)
             return operator_separator.join(['ENABLE(%s)' % expression for expression in sorted(conditions)])
     return 'ENABLE(%s)' % conditional
 
 
+def generate_constants(interface):
+    return [generate_constant(constant) for constant in interface.constants]
+
+
+def generate_constant(constant):
+    # Extended Attributes: Conditional, DeprecateAs, EnabledAtRuntime, Reflect
+    # FIXME: Conditional only used in tests, so remove
+    # (Blink-only) string literals are unquoted in tokenizer, must be re-quoted
+    # in C++.
+    if constant.data_type == 'DOMString':
+        value = '"%s"' % constant.value
+    else:
+        value = constant.value
+    reflected_name = constant.extended_attributes.get('Reflect', constant.name)
+
+    constant_parameter = {
+        'name': constant.name,
+        # FIXME: use 'reflected_name' as correct 'name'
+        'reflected_name': reflected_name,
+        'value': value,
+        # FIXME: remove conditional: only used in tests
+        'conditional_string': generate_conditional_string(constant),
+        'enabled_at_runtime': 'EnabledAtRuntime' in constant.extended_attributes,
+        'enable_function': runtime_enable_function_name(constant),

[haraken, 2013/08/26 09:33:40]

Nit: enable_function => runtime_enable_function_name ?

[Nils Barth (inactive), 2013/08/27 02:59:27]

Good point, done!

+    }
+    return constant_parameter
+
+
+def runtime_enable_function_name(definition_or_member):
+    """Return the name of the RuntimeEnabledFeatures function.
+
+    The returned function checks if a method/attribute is enabled.
+    If a parameter is given (e.g. 'EnabledAtRuntime=FeatureName'), return:
+        RuntimeEnabledFeatures::{featureName}Enabled
+    Otherwise return:
+        RuntimeEnabledFeatures::{methodName}Enabled
+    """
+    name = definition_or_member.extended_attributes.get('EnabledAtRuntime') or definition_or_member.name
+    return 'RuntimeEnabledFeatures::%sEnabled' % uncapitalize(name)
+
+
+def uncapitalize(name):
+    """Uncapitalize first letter or initial acronym (* with some exceptions).
+
+    E.g., 'SetURL' becomes 'setURL', but 'URLFoo' becomes 'urlFoo'.
+    Used in method names; exceptions differ from capitalize().
+    """
+    for acronym in ACRONYMS:
+        if name.startswith(acronym):
+            name.replace(acronym, acronym.lower())
+            return name
+    return name[0].lower() + name[1:]
+
+
 def includes_for_type(data_type):
     if primitive_type(data_type) or data_type == 'DOMString':
         return set()
     if array_or_sequence_type(data_type):
         return includes_for_type(array_or_sequence_type(data_type))
     return set(['V8%s.h' % data_type])
 
 
 def includes_for_cpp_class(class_name, relative_dir_posix):
     return set([posixpath.join(relative_dir_posix, class_name + '.h')])
@@ skipping 20 matching lines @@
 def array_type(data_type):
     matched = re.match(r'([\w\d_\s]+)\[\]', data_type)
     if not matched:
         return None
     return matched.group(1)
 
 
 def array_or_sequence_type(data_type):
     return array_type(data_type) or sequence_type(data_type)
 
-def cpp_type(data_type, pointer_type):
+
+def cpp_type(idl_type, pointer_type=None):
     """Returns the C++ type corresponding to the IDL type.
 
+    If unidentified, fall back to a pointer.
+
     Args:
-        pointer_type:
-            'raw': return raw pointer form (e.g. Foo*)
-            'RefPtr': return RefPtr form (e.g. RefPtr<Foo>)
-            'PassRefPtr': return PassRefPtr form (e.g. RefPtr<Foo>)
+        idl_type: IDL type
+        pointer_type: If specified, return 'pointer_type<idl_type>'
+            (e.g. RefPtr<Foo>, PassRefPtr<Foo>)
+            else defaults to returning raw pointer form (e.g. 'Foo*').
     """
-    if data_type in CPP_TYPE_SPECIAL_CONVERSION_RULES:
-        return CPP_TYPE_SPECIAL_CONVERSION_RULES[data_type]
-    if array_or_sequence_type(data_type):
-        return 'const Vector<%s >&' % cpp_type(array_or_sequence_type(data_type), 'RefPtr')
-    if pointer_type == 'raw':
-        return data_type + '*'
-    if pointer_type in ['RefPtr', 'PassRefPtr']:
-        return '%s<%s>' % (pointer_type, data_type)
-    raise Exception('Unrecognized pointer type: "%s"' % pointer_type)
+    if idl_type in CPP_TYPE_SPECIAL_CONVERSION_RULES:
+        return CPP_TYPE_SPECIAL_CONVERSION_RULES[idl_type]
+    if idl_type in CPP_UNSIGNED_TYPES:
+        return 'unsigned'
+    if array_or_sequence_type(idl_type):
+        return 'const Vector<{cpp_type} >&'.format(cpp_type=cpp_type(array_or_sequence_type(idl_type), 'RefPtr'))
+    # Fall back to pointer

[haraken, 2013/08/26 09:33:40]

Nit: I'd drop the comment.

[Nils Barth (inactive), 2013/08/27 02:59:27]

Done (covered in docstring anyway).

+    if pointer_type:
+        return '{pointer_type}<{idl_type}>'.format(pointer_type=pointer_type, idl_type=idl_type)
+    return idl_type + '*'  # raw pointer
 
 
 def v8_type(data_type):
     return 'V8' + data_type
 
 
 def cpp_method_name(attribute_or_operation):
     return attribute_or_operation.extended_attributes.get('ImplementedAs', attribute_or_operation.name)
 
 
@@ skipping 15 matching lines @@
         self.verbose = verbose
         self.interface = None
         self.header_includes = set()
         self.cpp_includes = set()
         if definitions:  # FIXME: remove check when remove write_dummy_header_and_cpp
             try:
                 self.interface = definitions.interfaces[interface_name]
             except KeyError:
                 raise Exception('%s not in IDL definitions' % interface_name)
 
-    def generate_cpp_to_js_conversion(self, data_type, cpp_value, format_string, isolate, creation_context=''):
-        """Returns a statement that converts a C++ value to a JS value.
+    def generate_cpp_to_v8_conversion(self, data_type, cpp_value, format_string, isolate, creation_context=''):
+        """Returns a statement that converts a C++ value to a V8 value.
 
         Also add necessary includes to self.cpp_includes.
         """
         self.cpp_includes |= includes_for_type(data_type)
-        js_value = cpp_value_to_js_value(data_type, cpp_value, isolate, creation_context)
-        return format_string % js_value
+        v8_value = cpp_value_to_v8_value(data_type, cpp_value, isolate, creation_context)
+        return format_string % v8_value
 
     def write_dummy_header_and_cpp(self):
         # FIXME: fix GYP so these files aren't needed and remove this method
         target_interface_name = self.interface_name
         header_basename = 'V8%s.h' % target_interface_name
         cpp_basename = 'V8%s.cpp' % target_interface_name
         contents = """/*
     This file is generated just to tell build scripts that {header_basename} and
     {cpp_basename} are created for {target_interface_name}.idl, and thus
     prevent the build scripts from trying to generate {header_basename} and
@@ skipping 24 matching lines @@
         header_filename = os.path.join(self.output_directory, header_basename)
         with open(header_filename, 'w') as header_file:
             header_file.write(header_file_text)
 
     def write_cpp_code(self, cpp_basename, cpp_file_text):
         cpp_filename = os.path.join(self.output_directory, cpp_basename)
         with open(cpp_filename, 'w') as cpp_file:
             cpp_file.write(cpp_file_text)
 
     def generate_attribute(self, attribute):
-        self.cpp_includes |= includes_for_type(attribute.data_type)
+        data_type = attribute.data_type
+        # FIXME: need to check should_keep_attribute_alive, but for now
+        # sufficient to check if primitive.
+        should_keep_attribute_alive = not primitive_type(data_type)
+        if should_keep_attribute_alive:
+            return_v8_value_statement = None  # unused
+            self.cpp_includes |= includes_for_type(data_type)
+            self.cpp_includes.add('bindings/v8/V8HiddenPropertyName.h')
+        else:
+            cpp_value = 'imp->%s()' % uncapitalize(attribute.name)
+            return_v8_value_statement = v8_set_return_value(data_type, cpp_value, callback_info='info')
         return {
             'name': attribute.name,
             'conditional_string': generate_conditional_string(attribute),
             'cpp_method_name': cpp_method_name(attribute),
-            'cpp_type': cpp_type(attribute.data_type, pointer_type='RefPtr'),
-            'v8_type': v8_type(attribute.data_type),
+            'cpp_type': cpp_type(data_type, pointer_type='RefPtr'),
+            'should_keep_attribute_alive': should_keep_attribute_alive,
+            'return_v8_value_statement': return_v8_value_statement,
+            'v8_type': v8_type(data_type),
         }
 
     def generate_interface(self):
         self.header_includes = INTERFACE_H_INCLUDES
         self.header_includes |= includes_for_cpp_class(cpp_class_name(self.interface), self.relative_dir_posix)
         self.cpp_includes = INTERFACE_CPP_INCLUDES
 
         template_contents = {
             'interface_name': self.interface.name,
             'cpp_class_name': cpp_class_name(self.interface),
             'v8_class_name': v8_class_name(self.interface),
             'attributes': [self.generate_attribute(attribute) for attribute in self.interface.attributes],
             # Size 0 constant array is not allowed in VC++
             'number_of_attributes': 'WTF_ARRAY_LENGTH(%sAttributes)' % v8_class_name(self.interface) if self.interface.attributes else '0',
             'attribute_templates': v8_class_name(self.interface) + 'Attributes' if self.interface.attributes else '0',
         }
+        template_contents['constants'] = generate_constants(self.interface)
         # Add includes afterwards, as they are modified by generate_attribute etc.
         template_contents['header_includes'] = sorted(list(self.header_includes))
         template_contents['cpp_includes'] = sorted(list(self.cpp_includes))
         return template_contents
 
     def generate_callback_interface(self):
         self.header_includes = CALLBACK_INTERFACE_H_INCLUDES
         self.header_includes |= includes_for_cpp_class(cpp_class_name(self.interface), self.relative_dir_posix)
         self.cpp_includes = CALLBACK_INTERFACE_CPP_INCLUDES
 
         def generate_argument(argument):
             receiver = 'v8::Handle<v8::Value> %sHandle = %%s;' % argument.name
-            cpp_to_js_conversion = self.generate_cpp_to_js_conversion(argument.data_type, argument.name, receiver, 'isolate', creation_context='v8::Handle<v8::Object>()')
+            cpp_to_v8_conversion = self.generate_cpp_to_v8_conversion(argument.data_type, argument.name, receiver, 'isolate', creation_context='v8::Handle<v8::Object>()')
             return {
                 'name': argument.name,
-                'cpp_to_js_conversion': cpp_to_js_conversion,
+                'cpp_to_v8_conversion': cpp_to_v8_conversion,
             }
 
         def generate_method(operation):
             def argument_declaration(argument):
-                return '%s %s' % (cpp_type(argument.data_type, 'raw'), argument.name)
+                return '%s %s' % (cpp_type(argument.data_type), argument.name)
 
             arguments = []
             custom = 'Custom' in operation.extended_attributes
             if not custom:
                 self.cpp_includes |= includes_for_operation(operation)
                 if operation.data_type != 'boolean':
                     raise Exception("We don't yet support callbacks that return non-boolean values.")
                 arguments = [generate_argument(argument) for argument in operation.arguments]
             method = {
                 'return_cpp_type': cpp_type(operation.data_type, 'RefPtr'),
                 'name': operation.name,
                 'arguments': arguments,
                 'argument_declaration': ', '.join([argument_declaration(argument) for argument in operation.arguments]),
                 'handles': ', '.join(['%sHandle' % argument.name for argument in operation.arguments]),
                 'custom': custom,
             }
             return method
 
         methods = [generate_method(operation) for operation in self.interface.operations]
         template_contents = {
             'cpp_class_name': self.interface.name,
             'v8_class_name': v8_class_name(self.interface),
             'cpp_includes': sorted(list(self.cpp_includes)),
             'header_includes': sorted(list(self.header_includes)),
             'methods': methods,
         }
         return template_contents