IDL: Improve "includes for type" mechanism in various ways

Source/bindings/scripts/v8_types.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 348 matching lines @@
                      'core/dom/NodeList.h',
                      'core/dom/StaticNodeList.h',
                      'core/html/LabelsNodeList.h']),
     'Promise': set(['bindings/core/v8/ScriptPromise.h']),
     'SerializedScriptValue': set(['bindings/core/v8/SerializedScriptValue.h',
                                   'bindings/core/v8/SerializedScriptValueFactory.h']),
     'ScriptValue': set(['bindings/core/v8/ScriptValue.h']),
 }
 
 
-def includes_for_type(idl_type):
+def includes_for_type(idl_type, extended_attributes=None):
     idl_type = idl_type.preprocessed_type
+    extended_attributes = extended_attributes or {}
 
     # Simple types
     base_idl_type = idl_type.base_type
     if base_idl_type in INCLUDES_FOR_TYPE:
         return INCLUDES_FOR_TYPE[base_idl_type]
     if idl_type.is_basic_type:
         return set()
     if base_idl_type.endswith('ConstructorConstructor'):
         # FIXME: rename to NamedConstructor
         # FIXME: replace with a [NamedConstructorAttribute] extended attribute
         # Ending with 'ConstructorConstructor' indicates a named constructor,
         # and these do not have header files, as they are part of the generated
         # bindings for the interface
         return set()
     if base_idl_type.endswith('Constructor'):
         # FIXME: replace with a [ConstructorAttribute] extended attribute
         base_idl_type = idl_type.constructor_type_name
     if base_idl_type not in component_dir:
         return set()
     return set(['bindings/%s/v8/V8%s.h' % (component_dir[base_idl_type],
                                            base_idl_type)])
 
-IdlType.includes_for_type = property(includes_for_type)
-IdlUnionType.includes_for_type = property(
-    lambda self: set.union(*[member_type.includes_for_type
-                             for member_type in self.member_types]))
-IdlArrayOrSequenceType.includes_for_type = property(
-    lambda self: self.element_type.includes_for_type)
+IdlType.includes_for_type = includes_for_type
 
 
-def add_includes_for_type(idl_type):
-    includes.update(idl_type.includes_for_type)
+def includes_for_union_type(idl_type, extended_attributes=None):
+    return set.union(*[member_type.includes_for_type(extended_attributes)
+                       for member_type in idl_type.member_types])
+
+IdlUnionType.includes_for_type = includes_for_union_type
+
+
+def includes_for_array_or_sequence_type(idl_type, extended_attributes=None):
+    return idl_type.element_type.includes_for_type(extended_attributes)
+
+IdlArrayOrSequenceType.includes_for_type = includes_for_array_or_sequence_type
+
+
+def add_includes_for_type(idl_type, extended_attributes=None):
+    includes.update(idl_type.includes_for_type(extended_attributes))
 
 IdlTypeBase.add_includes_for_type = add_includes_for_type
 
 
 def includes_for_interface(interface_name):
-    return IdlType(interface_name).includes_for_type
+    return IdlType(interface_name).includes_for_type()
 
 
 def add_includes_for_interface(interface_name):
     includes.update(includes_for_interface(interface_name))
 
 
 def impl_should_use_nullable_container(idl_type):
     return not(idl_type.cpp_type_has_null_value)
 
 IdlTypeBase.impl_should_use_nullable_container = property(
@@ skipping 113 matching lines @@
     if idl_type.name == 'void':
         return ''
 
     # Array or sequence types
     native_array_element_type = idl_type.native_array_element_type
     if native_array_element_type:
         return v8_value_to_cpp_value_array_or_sequence(native_array_element_type, v8_value, index, isolate)
 
     # Simple types
     idl_type = idl_type.preprocessed_type
-    add_includes_for_type(idl_type)
     base_idl_type = idl_type.as_union_type.name if idl_type.is_union_type else idl_type.base_type
 
     if idl_type.is_integer_type:
         configuration = 'NormalConversion'
         if 'EnforceRange' in extended_attributes:
             configuration = 'EnforceRange'
         elif 'Clamp' in extended_attributes:
             configuration = 'Clamp'
         arguments = ', '.join([v8_value, configuration, 'exceptionState'])
     elif idl_type.v8_conversion_needs_exception_state:
@@ skipping 22 matching lines @@
     # and is used to provide a human-readable exception message
     if index is None:
         index = 0  # special case, meaning "setter"
     else:
         index += 1  # human-readable index
     if (native_array_element_type.is_interface_type and
         native_array_element_type.name != 'Dictionary'):
         this_cpp_type = None
         ref_ptr_type = cpp_ptr_type('RefPtr', 'Member', native_array_element_type.gc_type)
         expression_format = '(to{ref_ptr_type}NativeArray<{native_array_element_type}, V8{native_array_element_type}>({v8_value}, {index}, {isolate}, exceptionState))'
-        add_includes_for_type(native_array_element_type)
     else:
         ref_ptr_type = None
         this_cpp_type = native_array_element_type.cpp_type
         expression_format = 'toImplArray<{cpp_type}>({v8_value}, {index}, {isolate}, exceptionState)'
     expression = expression_format.format(native_array_element_type=native_array_element_type.name, cpp_type=this_cpp_type, index=index, ref_ptr_type=ref_ptr_type, v8_value=v8_value, isolate=isolate)
     return expression
 
 
 # FIXME: this function should be refactored, as this takes too many flags.
 def v8_value_to_local_cpp_value(idl_type, extended_attributes, v8_value, variable_name, index=None, declare_variable=True, isolate='info.GetIsolate()', bailout_return_value=None, use_exception_state=False, restricted_float=False):
@@ skipping 126 matching lines @@
     # non-nullable dictionaries or unions.
     if idl_type.is_dictionary and idl_type.is_nullable:
         return 'NullableDictionary'
 
     if idl_type.is_dictionary or idl_type.is_union_type:
         return 'DictionaryOrUnion'
 
     # Array or sequence types
     native_array_element_type = idl_type.native_array_element_type
     if native_array_element_type:
-        if native_array_element_type.is_interface_type:
-            add_includes_for_type(native_array_element_type)
         return 'array'
 
     # Simple types
     base_idl_type = idl_type.base_type
     # Basic types, without additional includes
     if base_idl_type in CPP_INT_TYPES:
         return 'int'
     if base_idl_type in CPP_UNSIGNED_TYPES:
         return 'unsigned'
     if idl_type.is_string_type:
         if idl_type.is_nullable:
             return 'StringOrNull'
         if 'TreatReturnedNullStringAs' not in extended_attributes:
             return base_idl_type
         treat_returned_null_string_as = extended_attributes['TreatReturnedNullStringAs']
         if treat_returned_null_string_as == 'Null':
             return 'StringOrNull'
         if treat_returned_null_string_as == 'Undefined':
             return 'StringOrUndefined'
         raise 'Unrecognized TreatReturnedNullStringAs value: "%s"' % treat_returned_null_string_as
     if idl_type.is_basic_type or base_idl_type == 'ScriptValue':
         return base_idl_type
     # Generic dictionary type
     if base_idl_type == 'Dictionary':
         return 'Dictionary'
 
     # Data type with potential additional includes
-    add_includes_for_type(idl_type)
     if base_idl_type in V8_SET_RETURN_VALUE:  # Special v8SetReturnValue treatment
         return base_idl_type
 
     # Pointer type
     return 'DOMWrapper'
 
 IdlTypeBase.v8_conversion_type = v8_conversion_type
 
 
 V8_SET_RETURN_VALUE = {
@@ skipping 198 matching lines @@
     number_of_nullable_member_types_union)
 
 
 def includes_nullable_type_union(idl_type):
     # http://heycam.github.io/webidl/#dfn-includes-a-nullable-type
     return idl_type.number_of_nullable_member_types == 1
 
 IdlTypeBase.includes_nullable_type = False
 IdlNullableType.includes_nullable_type = True
 IdlUnionType.includes_nullable_type = property(includes_nullable_type_union)