IDL compiler: constructor attributes

Source/bindings/scripts/unstable/v8_attributes.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 19 matching lines @@
 
 FIXME: Not currently used in build.
 This is a rewrite of the Perl IDL compiler in Python, but is not complete.
 Once it is complete, we will switch all IDL files over to Python at once.
 Until then, please work on the Perl IDL compiler.
 For details, see bug http://crbug.com/239771
 """
 
 import v8_types
 import v8_utilities
-from v8_utilities import capitalize, cpp_name, has_extended_attribute, uncapitalize
+from v8_utilities import capitalize, cpp_name, has_extended_attribute, strip_suffix, uncapitalize
 
 
 def generate_attributes(interface):
     def generate_attribute(attribute):
         attribute_contents, attribute_includes = generate_attribute_and_includes(interface, attribute)
         includes.update(attribute_includes)
         return attribute_contents
 
     includes = set()
     attributes = [generate_attribute(attribute) for attribute in interface.attributes]
     contents = {'attributes': attributes}
     contents.update(generate_attributes_common(interface, attributes))
     return contents, includes
 
 
 def generate_attributes_common(interface, attributes):
     v8_class_name = v8_utilities.v8_class_name(interface)
     return {
         'has_per_context_enabled_attributes': any(attribute['per_context_enabled_function_name'] for attribute in attributes),
+        'has_constructor_getter': any(attribute['is_constructor'] for attribute in attributes),
         'has_replaceable_attributes': any(attribute['is_replaceable'] for attribute in attributes),
         'has_runtime_enabled_attributes': any(attribute['runtime_enabled_function_name'] for attribute in attributes),
         'installed_attributes': '%sAttributes' % v8_class_name if attributes else '0',
         # Size 0 constant array is not allowed in VC++
         'number_of_attributes': 'WTF_ARRAY_LENGTH(%sAttributes)' % v8_class_name if attributes else '0',
     }
 
 
 def generate_attribute_and_includes(interface, attribute):
     idl_type = attribute.data_type
     extended_attributes = attribute.extended_attributes
 
     has_custom_getter = has_extended_attribute(attribute, ('Custom', 'CustomGetter'))
     is_replaceable = 'Replaceable' in attribute.extended_attributes
     has_custom_setter = (
             (not attribute.is_read_only or is_replaceable) and
             has_extended_attribute(attribute, ('Custom', 'CustomSetter')))
     includes = set()
     contents = {
         'access_control_list': access_control_list(attribute),
         'activity_logging_world_list_for_getter': v8_utilities.activity_logging_world_list(attribute, includes, 'Getter'),  # [ActivityLogging]
         'activity_logging_world_list_for_setter': v8_utilities.activity_logging_world_list(attribute, includes, 'Setter'),  # [ActivityLogging]
         'cached_attribute_validation_method': extended_attributes.get('CachedAttribute'),
         'conditional_string': v8_utilities.generate_conditional_string(attribute),
         'cpp_type': v8_types.cpp_type(idl_type),
+        'data': installation_data(attribute),
         'getter_callback_name': getter_callback_name(interface, attribute),
         'getter_callback_name_for_main_world': getter_callback_name_for_main_world(interface, attribute),
         'has_custom_getter': has_custom_getter,
         'has_custom_setter': has_custom_setter,
         'idl_type': idl_type,
+        'is_constructor': is_constructor(attribute),
         'is_getter_raises_exception': has_extended_attribute(attribute, ('GetterRaisesException', 'RaisesException')),
         'is_keep_alive_for_gc': is_keep_alive_for_gc(attribute),
         'is_nullable': attribute.is_nullable,
         'is_read_only': attribute.is_read_only,
         'is_replaceable': is_replaceable,
         'is_setter_raises_exception': has_extended_attribute(attribute, ('RaisesException', 'SetterRaisesException')),
         'is_static': attribute.is_static,
         'name': attribute.name,
         'per_context_enabled_function_name': v8_utilities.per_context_enabled_function_name(attribute),  # [PerContextEnabled]
         'property_attributes': property_attributes(attribute),
         'setter_callback_name': setter_callback_name(interface, attribute),
         'setter_callback_name_for_main_world': setter_callback_name_for_main_world(interface, attribute),
         'v8_type': v8_types.v8_type(idl_type),
         'runtime_enabled_function_name': v8_utilities.runtime_enabled_function_name(attribute),  # [RuntimeEnabled]
         'world_suffixes': ['', 'ForMainWorld'] if 'PerWorldBindings' in extended_attributes else [''],  # [PerWorldBindings]
     }
+    if is_constructor(attribute):
+        includes.update(v8_types.includes_for_type(idl_type))
+        return contents, includes
     if not has_custom_getter:
         generate_getter(interface, attribute, contents, includes)
     if not (attribute.is_read_only or has_custom_setter):
         generate_setter(interface, attribute, contents, includes)
 
     return contents, includes
 
 
+# Getter
+
 def generate_getter(interface, attribute, contents, includes):
     idl_type = attribute.data_type
     includes.update(v8_types.includes_for_type(idl_type))
     extended_attributes = attribute.extended_attributes
 
     cpp_value = getter_expression(interface, attribute, contents, includes)
     # Normally we can inline the function call into the return statement to
     # avoid the overhead of using a Ref<> temporary, but for some cases
     # (nullable types, EventHandler, [CachedAttribute], or if there are
     # exceptions), we need to use a local variable.
@@ skipping 94 matching lines @@
          not(
              # Node lifetime is managed by object grouping.
              v8_types.is_dom_node_type(idl_type) or
              # A self-reference is unnecessary.
              attribute.name == 'self' or
              # FIXME: Remove these hard-coded hacks.
              idl_type in ['EventHandler', 'Promise', 'Window'] or
              idl_type.startswith('HTML'))))
 
 
+# Setter
+
 def generate_setter(interface, attribute, contents, includes):
     idl_type = attribute.data_type
     extended_attributes = attribute.extended_attributes
     if v8_types.is_interface_type(idl_type) and not v8_types.array_type(idl_type):
         cpp_value = 'WTF::getPtr(cppValue)'
     else:
         cpp_value = 'cppValue'
     is_reflect = 'Reflect' in extended_attributes
     if is_reflect:
         includes.add('core/dom/custom/CustomElementCallbackDispatcher.h')
@@ skipping 63 matching lines @@
     includes.add('%s.h' % namespace)
     return '%s::%sAttr' % (namespace, content_attribute_name)
 
 
 def scoped_name(interface, attribute, base_name):
     if attribute.is_static:
         return '%s::%s' % (interface.name, base_name)
     return 'imp->%s' % base_name
 
 
+# Attribute configuration

[Nils Barth (inactive), 2013/10/23 11:31:34]

(Reordered in order of the configuration line.)

+
 def getter_callback_name(interface, attribute):
+    if attribute.data_type.endswith('Constructor'):
+        return '{0}V8Internal::{0}ConstructorGetter'.format(cpp_name(interface))
     return '%sV8Internal::%sAttributeGetterCallback' % (cpp_name(interface), attribute.name)
 
 
+# [Replaceable]
 def setter_callback_name(interface, attribute):
     if (attribute.is_read_only and
         'Replaceable' not in attribute.extended_attributes):
         # FIXME: support [PutForwards]
         return '0'
     cpp_class_name = cpp_name(interface)
-    if ('Replaceable' in attribute.extended_attributes and
-        not has_extended_attribute(attribute, ('Custom', 'CustomSetter'))):
+    if (('Replaceable' in attribute.extended_attributes and
+         not has_extended_attribute(attribute, ('Custom', 'CustomSetter'))) or
+        attribute.data_type.endswith('Constructor')):
         # Non-custom replaceable attributes have a single interface-level
         # setter callback (rather than individual attribute-level callbacks),
         # but custom replaceable attributes have individual callbacks, as usual.
         return '{0}V8Internal::{0}ReplaceableAttributeSetterCallback'.format(cpp_class_name)
     return '%sV8Internal::%sAttributeSetterCallback' % (cpp_class_name, attribute.name)
 
 
+# [PerWorldBindings]
+def getter_callback_name_for_main_world(interface, attribute):
+    if 'PerWorldBindings' not in attribute.extended_attributes:
+        return '0'
+    return '%sV8Internal::%sAttributeGetterCallbackForMainWorld' % (cpp_name(interface), attribute.name)
+
+
+def setter_callback_name_for_main_world(interface, attribute):
+    if ('PerWorldBindings' not in attribute.extended_attributes or
+        attribute.is_read_only):
+        return '0'
+    return '%sV8Internal::%sAttributeSetterCallbackForMainWorld' % (cpp_name(interface), attribute.name)
+
+
+def installation_data(attribute):
+    if not is_constructor(attribute):
+        return '0'
+    return '&V8%s::info' % v8_types.constructor_type(attribute.data_type)
+
+
 # [DoNotCheckSecurity], [DoNotCheckSecurityOnGetter], [DoNotCheckSecurityOnSetter], [Unforgeable]
 def access_control_list(attribute):
     extended_attributes = attribute.extended_attributes
     access_control = []
     if 'DoNotCheckSecurity' in extended_attributes:
         access_control.append('v8::ALL_CAN_READ')
         if not attribute.is_read_only:
             access_control.append('v8::ALL_CAN_WRITE')
     if 'DoNotCheckSecurityOnSetter' in extended_attributes:
         access_control.append('v8::ALL_CAN_WRITE')
     if 'DoNotCheckSecurityOnGetter' in extended_attributes:
         access_control.append('v8::ALL_CAN_READ')
     if 'Unforgeable' in extended_attributes:
         access_control.append('v8::PROHIBITS_OVERWRITING')
     return access_control or ['v8::DEFAULT']
 
 
 # [NotEnumerable], [Unforgeable]
 def property_attributes(attribute):
     extended_attributes = attribute.extended_attributes
     property_attributes_list = []
-    if 'NotEnumerable' in extended_attributes:
+    if ('NotEnumerable' in extended_attributes or
+        is_constructor(attribute)):
         property_attributes_list.append('v8::DontEnum')
     if 'Unforgeable' in extended_attributes:
         property_attributes_list.append('v8::DontDelete')
     return property_attributes_list or ['v8::None']
 
 
-# [PerWorldBindings]
-def getter_callback_name_for_main_world(interface, attribute):
-    if 'PerWorldBindings' not in attribute.extended_attributes:
-        return '0'
-    return '%sV8Internal::%sAttributeGetterCallbackForMainWorld' % (cpp_name(interface), attribute.name)
-
-
-def setter_callback_name_for_main_world(interface, attribute):
-    if ('PerWorldBindings' not in attribute.extended_attributes or
-        attribute.is_read_only):
-        return '0'
-    return '%sV8Internal::%sAttributeSetterCallbackForMainWorld' % (cpp_name(interface), attribute.name)
+def is_constructor(attribute):
+    return attribute.data_type.endswith('Constructor')