IDL: Use IdlArrayOrSequenceType for array/sequence IDL types

Source/bindings/scripts/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 122 matching lines @@
         'property_attributes': property_attributes(attribute),
         'put_forwards': 'PutForwards' in extended_attributes,
         'reflect_empty': extended_attributes.get('ReflectEmpty'),
         'reflect_invalid': extended_attributes.get('ReflectInvalid', ''),
         'reflect_missing': extended_attributes.get('ReflectMissing'),
         'reflect_only': extended_attributes['ReflectOnly'].split('|')
             if 'ReflectOnly' in extended_attributes else None,
         'runtime_enabled_function': v8_utilities.runtime_enabled_function_name(attribute),  # [RuntimeEnabled]
         'setter_callback': setter_callback_name(interface, attribute),
         'should_be_exposed_to_script': not (is_implemented_in_private_script and is_only_exposed_to_private_script),
-        'v8_type': v8_types.v8_type(base_idl_type),
+        'v8_type': v8_types.v8_type(base_idl_type) if idl_type.is_interface_type else None,

[Nils Barth (inactive), 2014/08/14 14:24:44]

Is this worth taking onto IdlType(Base)?
IdlType(Base).v8_type = property(lambda self:
    v8_type(self.base_idl_type) if self.is_interface_type else None)
...or the like?

[Jens Widell, 2014/08/14 15:02:55]

Can't think of a reason not to. :-)

         'world_suffixes': ['', 'ForMainWorld']
                           if 'PerWorldBindings' in extended_attributes
                           else [''],  # [PerWorldBindings]
     }
 
     if is_constructor_attribute(attribute):
         constructor_getter_context(interface, attribute, context)
         return context
     if not has_custom_getter(attribute):
         getter_context(interface, attribute, context)
@@ skipping 214 matching lines @@
     elif idl_type.base_type == 'EventHandler':
         getter_name = scoped_name(interface, attribute, cpp_name(attribute))
         context['event_handler_getter_expression'] = '%s(%s)' % (
             getter_name, ', '.join(arguments))
         if (interface.name in ['Window', 'WorkerGlobalScope'] and
             attribute.name == 'onerror'):
             includes.add('bindings/core/v8/V8ErrorHandler.h')
             arguments.append('V8EventListenerList::findOrCreateWrapper<V8ErrorHandler>(v8Value, true, ScriptState::current(info.GetIsolate()))')
         else:
             arguments.append('V8EventListenerList::getEventListener(ScriptState::current(info.GetIsolate()), v8Value, true, ListenerFindOrCreate)')
-    elif idl_type.is_interface_type and not idl_type.array_element_type:
+    elif idl_type.is_interface_type:
         # FIXME: should be able to eliminate WTF::getPtr in most or all cases
         arguments.append('WTF::getPtr(cppValue)')
     else:
         arguments.append('cppValue')
     if context['is_setter_raises_exception']:
         arguments.append('exceptionState')
 
     return '%s(%s)' % (setter_name, ', '.join(arguments))
 
 
@@ skipping 100 matching lines @@
 # Constructors
 ################################################################################
 
 idl_types.IdlType.constructor_type_name = property(
     # FIXME: replace this with a [ConstructorAttribute] extended attribute
     lambda self: strip_suffix(self.base_type, 'Constructor'))
 
 
 def is_constructor_attribute(attribute):
     # FIXME: replace this with [ConstructorAttribute] extended attribute
-    return attribute.idl_type.base_type.endswith('Constructor')
+    return attribute.idl_type.name.endswith('Constructor')

[Jens Widell, 2014/08/14 13:56:50]

Changed since base_type is sometimes None (more often so now.) This would fail
if the attribute was nullable, but that doesn't seem likely. Besides, there's
already a FIXME about improving it.

[Nils Barth (inactive), 2014/08/14 14:24:44]

Acknowledged; [ConstructorAttribute] is another long-overdue cleanup.

 
 
 def constructor_getter_context(interface, attribute, context):
     context['needs_constructor_getter_callback'] = context['measure_as'] or context['deprecate_as']