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 35 matching lines @@
                   for attribute in interface.attributes]
     contents = {'attributes': attributes}
     contents.update(generate_attributes_common(interface, attributes))
     return contents
 
 
 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_attributes': 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(interface, attribute):
     idl_type = attribute.data_type
     extended_attributes = attribute.extended_attributes
 
     has_custom_getter = has_extended_attribute(attribute, ('Custom', 'CustomGetter'))
     has_custom_setter = not attribute.is_read_only and has_extended_attribute(attribute, ('Custom', 'CustomSetter'))
     contents = {
         'access_control_list': access_control_list(attribute),
         'activity_logging_world_list_for_getter': v8_utilities.activity_logging_world_list(attribute, 'Getter'),  # [ActivityLogging]
         'activity_logging_world_list_for_setter': v8_utilities.activity_logging_world_list(attribute, '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),
         '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(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': 'Replaceable' in attribute.extended_attributes,
         '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]
+        'wrapper_type_info': wrapper_type_info(attribute),
     }
+    if is_constructor_attribute(attribute):
+        includes.update(v8_types.includes_for_type(idl_type))
+        return contents, includes
     if not has_custom_getter:
         generate_getter(interface, attribute, contents)
     if not attribute.is_read_only and not has_custom_setter:
         generate_setter(interface, attribute, contents)
 
     return contents
 
 
+# Getter
+
 def generate_getter(interface, attribute, contents):
     idl_type = attribute.data_type
     v8_types.add_includes_for_type(idl_type)
     extended_attributes = attribute.extended_attributes
 
     cpp_value = getter_expression(interface, attribute, contents)
     # 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 92 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):
     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
+
 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):
     cpp_class_name = cpp_name(interface)
-    if 'Replaceable' in attribute.extended_attributes:
+    if ('Replaceable' in attribute.extended_attributes or
+        attribute.data_type.endswith('Constructor')):
+        # FIXME: rename to ForceSetAttributeOnThisCallback, since also used for Constructors
         return '{0}V8Internal::{0}ReplaceableAttributeSetterCallback'.format(cpp_class_name)
     # FIXME: support [PutForwards]
     if attribute.is_read_only:
         return '0'
     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 wrapper_type_info(attribute):
+    if not is_constructor_attribute(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(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(attribute):
+    return attribute.data_type.endswith('Constructor')