Dartium Roll 38 roll

bindings/dart/scripts/dart_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 20 matching lines @@
 Extends IdlType and IdlUnionType with C++-specific properties, methods, and
 class methods.
 
 Spec:
 http://www.w3.org/TR/WebIDL/#es-type-mapping
 
 Design doc: http://www.chromium.org/developers/design-documents/idl-compiler
 """
 
 import posixpath
-from idl_types import IdlType, IdlUnionType, TYPE_NAMES
+from idl_types import IdlTypeBase, IdlType, IdlUnionType, TYPE_NAMES, IdlArrayOrSequenceType
+
 import dart_attributes  # for IdlType.constructor_type_name
 from dart_utilities import DartUtilities
 from v8_globals import includes
 
 
 ################################################################################
 # CPP -specific handling of IDL types for Dart:Blink
 ################################################################################
 
 NON_WRAPPER_TYPES = frozenset([
@@ skipping 13 matching lines @@
     'Float64Array': ('double', 'Float64List'),
     'Int8Array': ('signed char', 'Int8List'),
     'Int16Array': ('short', 'Int16List'),
     'Int32Array': ('int', 'Int32List'),
     'Uint8Array': ('unsigned char', 'Uint8List'),
     'Uint8ClampedArray': ('unsigned char', 'Uint8ClampedList'),
     'Uint16Array': ('unsigned short', 'Uint16List'),
     'Uint32Array': ('unsigned int', 'Uint32List'),
 }
 
-IdlType.is_typed_array_type = property(
+
+IdlTypeBase.is_typed_array_type = property(
     lambda self: self.base_type in TYPED_ARRAYS)
 
 
 IdlType.is_wrapper_type = property(
     lambda self: (self.is_interface_type and
                   self.base_type not in NON_WRAPPER_TYPES))
 
 
 ################################################################################
 # C++ types
@@ skipping 25 matching lines @@
     'Promise': 'ScriptPromise',
     'ScriptValue': 'ScriptValue',
     # FIXME: Eliminate custom bindings for XPathNSResolver  http://crbug.com/345529
     'XPathNSResolver': 'RefPtrWillBeRawPtr<XPathNSResolver>',
     'boolean': 'bool',
     'unrestricted double': 'double',
     'unrestricted float': 'float',
 }
 
 
-def cpp_type(idl_type, extended_attributes=None, used_as_argument=False, used_in_cpp_sequence=False):
+def cpp_type(idl_type, extended_attributes=None, raw_type=False, used_as_rvalue_type=False, used_in_cpp_sequence=False):
     """Returns C++ type corresponding to IDL type.
 
     |idl_type| argument is of type IdlType, while return value is a string
 
     Args:
         idl_type:
             IdlType
-        used_as_argument:
+        raw_type:
             bool, True if idl_type's raw/primitive C++ type should be returned.
-        will_be_in_heap_object:
-            bool, True if idl_type will be part of a possibly heap allocated
-            object (e.g., appears as an element of a C++ heap vector type.)
-            The C++ type of an interface type changes, if so.
+        used_as_rvalue_type:
+            bool, True if the C++ type is used as an argument or the return
+            type of a method.
+        used_as_variadic_argument:
+            bool, True if the C++ type is used as a variadic argument of a method.
+        used_in_cpp_sequence:
+            bool, True if the C++ type is used as an element of a container.
+            Containers can be an array, a sequence or a dictionary.
     """
     extended_attributes = extended_attributes or {}
     idl_type = idl_type.preprocessed_type
 
     # Composite types
-    array_or_sequence_type = idl_type.array_or_sequence_type
-    if array_or_sequence_type:
-        vector_type = cpp_ptr_type('Vector', 'HeapVector', array_or_sequence_type.gc_type)
-        return cpp_template_type(vector_type, array_or_sequence_type.cpp_type_args(used_in_cpp_sequence=True))
+    native_array_element_type = idl_type.native_array_element_type
+    if native_array_element_type:
+        vector_type = cpp_ptr_type('Vector', 'HeapVector', native_array_element_type.gc_type)
+        return cpp_template_type(vector_type, native_array_element_type.cpp_type_args(used_in_cpp_sequence=True))
 
     # Simple types
     base_idl_type = idl_type.base_type
 
     if base_idl_type in CPP_TYPE_SAME_AS_IDL_TYPE:
         return base_idl_type
     if base_idl_type in CPP_INT_TYPES:
         return 'int'
     if base_idl_type in CPP_UNSIGNED_TYPES:
         return 'unsigned'
     if base_idl_type in CPP_SPECIAL_CONVERSION_RULES:
         return CPP_SPECIAL_CONVERSION_RULES[base_idl_type]
 
     if base_idl_type in NON_WRAPPER_TYPES:
-        return 'RefPtr<%s>' % base_idl_type
+        return ('PassRefPtr<%s>' if used_as_rvalue_type else 'RefPtr<%s>') % base_idl_type
     if base_idl_type in ('DOMString', 'ByteString', 'ScalarValueString'):
-        if not used_as_argument:
+        if not raw_type:
             return 'String'
         return 'DartStringAdapter'
 
-    if idl_type.is_typed_array_type and used_as_argument:
+    if idl_type.is_typed_array_type and raw_type:
         return 'RefPtr<%s>' % base_idl_type
     if idl_type.is_callback_interface:
         return 'OwnPtr<%s>' % base_idl_type
     if idl_type.is_interface_type:
         implemented_as_class = idl_type.implemented_as
-        if used_as_argument:
+        if raw_type:
             return implemented_as_class + '*'
         new_type = 'Member' if used_in_cpp_sequence else 'RawPtr'
-        ptr_type = cpp_ptr_type('RefPtr', new_type, idl_type.gc_type)
+        ptr_type = cpp_ptr_type(('PassRefPtr' if used_as_rvalue_type else 'RefPtr'), new_type, idl_type.gc_type)
         return cpp_template_type(ptr_type, implemented_as_class)
 
     # Default, assume native type is a pointer with same type name as idl type
     return base_idl_type + '*'
 
 
-def cpp_type_union(idl_type, extended_attributes=None, used_as_argument=False, will_be_in_heap_object=False):
+def cpp_type_union(idl_type, extended_attributes=None, used_as_rvalue_type=False, will_be_in_heap_object=False):
     return (member_type.cpp_type for member_type in idl_type.member_types)
 
+
 # Allow access as idl_type.cpp_type if no arguments
-IdlType.cpp_type = property(cpp_type)
+IdlTypeBase.cpp_type = property(cpp_type)
+IdlTypeBase.cpp_type_args = cpp_type
 IdlUnionType.cpp_type = property(cpp_type_union)
-IdlType.cpp_type_args = cpp_type
 IdlUnionType.cpp_type_args = cpp_type_union
 
 
+IdlTypeBase.native_array_element_type = None
+IdlArrayOrSequenceType.native_array_element_type = property(
+    lambda self: self.element_type)
+
+
 def cpp_template_type(template, inner_type):
     """Returns C++ template specialized to type, with space added if needed."""
     if inner_type.endswith('>'):
         format_string = '{template}<{inner_type} >'
     else:
         format_string = '{template}<{inner_type}>'
     return format_string.format(template=template, inner_type=inner_type)
 
 
 def cpp_ptr_type(old_type, new_type, gc_type):
@@ skipping 31 matching lines @@
         return IdlType.implemented_as_interfaces[base_idl_type]
     return base_idl_type
 
 
 IdlType.implemented_as = property(implemented_as)
 
 IdlType.set_implemented_as_interfaces = classmethod(
     lambda cls, new_implemented_as_interfaces:
         cls.implemented_as_interfaces.update(new_implemented_as_interfaces))
 
+
 # [GarbageCollected]
 IdlType.garbage_collected_types = set()
 
+IdlTypeBase.is_garbage_collected = False
 IdlType.is_garbage_collected = property(
     lambda self: self.base_type in IdlType.garbage_collected_types)
 
 IdlType.set_garbage_collected_types = classmethod(
     lambda cls, new_garbage_collected_types:
         cls.garbage_collected_types.update(new_garbage_collected_types))
 
 
 # [WillBeGarbageCollected]
 IdlType.will_be_garbage_collected_types = set()
 
+IdlTypeBase.is_will_be_garbage_collected = False
 IdlType.is_will_be_garbage_collected = property(
     lambda self: self.base_type in IdlType.will_be_garbage_collected_types)
 
 IdlType.set_will_be_garbage_collected_types = classmethod(
     lambda cls, new_will_be_garbage_collected_types:
         cls.will_be_garbage_collected_types.update(new_will_be_garbage_collected_types))
 
 
 def gc_type(idl_type):
     if idl_type.is_garbage_collected:
         return 'GarbageCollectedObject'
     if idl_type.is_will_be_garbage_collected:
         return 'WillBeGarbageCollectedObject'
     return 'RefCountedObject'
 
-IdlType.gc_type = property(gc_type)
+IdlTypeBase.gc_type = property(gc_type)
 
 
 ################################################################################
 # Includes
 ################################################################################
 
 def includes_for_cpp_class(class_name, relative_dir_posix):
     return set([posixpath.join('bindings', relative_dir_posix, class_name + '.h')])
 
 # TODO(terry): Will we need this group header for dart:blink?
 INCLUDES_FOR_TYPE = {
     'object': set(),
     'CompareHow': set(),
-    'Dictionary': set(['bindings/common/Dictionary.h']),
+    'Dictionary': set(['bindings/core/v8/Dictionary.h']),
     'EventHandler': set(),
     'EventListener': set(),
     'HTMLCollection': set(['bindings/core/dart/DartHTMLCollection.h',
                            'core/dom/ClassCollection.h',
                            'core/dom/TagCollection.h',
                            'core/html/HTMLCollection.h',
                            'core/html/HTMLFormControlsCollection.h',
                            'core/html/HTMLTableRowsCollection.h']),
     'MediaQueryListListener': set(['core/css/MediaQueryListListener.h']),
     'NodeList': set(['bindings/core/dart/DartNodeList.h',
                      'core/dom/NameNodeList.h',
                      'core/dom/NodeList.h',
                      'core/dom/StaticNodeList.h',
                      'core/html/LabelsNodeList.h']),
     'Promise': set(),
     'SerializedScriptValue': set(),
-    'ScriptValue': set(['bindings/dart/DartScriptValue.h']),
+    'ScriptValue': set(['bindings/core/dart/DartScriptValue.h']),
 }
 
 
 def includes_for_type(idl_type):
     idl_type = idl_type.preprocessed_type
 
     # Composite types
-    array_or_sequence_type = idl_type.array_or_sequence_type
-    if array_or_sequence_type:
-        return includes_for_type(array_or_sequence_type)
+    if idl_type.native_array_element_type:
+        return includes_for_type(idl_type)
 
     # 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 idl_type.is_typed_array_type:
         # Typed array factory methods are already provided by DartUtilities.h.
         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
-    return set(['Dart%s.h' % base_idl_type])
+    if base_idl_type not in component_dir:
+        return set()
+    return set(['bindings/%s/dart/Dart%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(*[includes_for_type(member_type)
                              for member_type in self.member_types]))
 
 
 def add_includes_for_type(idl_type):
     includes.update(idl_type.includes_for_type)
 
-IdlType.add_includes_for_type = add_includes_for_type
+IdlTypeBase.add_includes_for_type = add_includes_for_type
 IdlUnionType.add_includes_for_type = add_includes_for_type
 
 
 def includes_for_interface(interface_name):
     return IdlType(interface_name).includes_for_type
 
 
 def add_includes_for_interface(interface_name):
     includes.update(includes_for_interface(interface_name))
 
 
+component_dir = {}
+
+
+def set_component_dirs(new_component_dirs):
+    component_dir.update(new_component_dirs)
+
+
 ################################################################################
 # Dart -> C++
 ################################################################################
 
 # TODO(terry): Need to fix to handle getter/setters for onEvent.
 DART_FIX_ME = 'DART_UNIMPLEMENTED(/* Conversion unimplemented*/);'
 
 # For a given IDL type, the DartHandle to C++ conversion.
 DART_TO_CPP_VALUE = {
     # Basic
@@ skipping 30 matching lines @@
     'XPathNSResolver': 'nullptr /* FIXME, DART_TO_CPP_VALUE[XPathNSResolver] */',
     # FIXME(vsm): This is an enum type (defined in StorageQuota.idl).
     # We should handle it automatically, but map to a String for now.
     'StorageType': 'DartUtilities::dartToString(args, {index}, exception, {auto_scope})',
 }
 
 
 def dart_value_to_cpp_value(idl_type, interface_extended_attributes, extended_attributes, variable_name,
                             null_check, index, auto_scope=True):
     # Composite types
-    array_or_sequence_type = idl_type.array_or_sequence_type
-    if array_or_sequence_type:
-        return dart_value_to_cpp_value_array_or_sequence(array_or_sequence_type, variable_name, index)
+    native_array_element_type = idl_type.native_array_element_type
+    if native_array_element_type:
+        return dart_value_to_cpp_value_array_or_sequence(native_array_element_type, variable_name, index)
 
     # Simple types
     idl_type = idl_type.preprocessed_type
     add_includes_for_type(idl_type)
     base_idl_type = idl_type.base_type
 
     if 'EnforceRange' in extended_attributes:
         arguments = ', '.join([variable_name, 'EnforceRange', 'exceptionState'])
     elif idl_type.is_integer_type:  # NormalConversion
         arguments = ', '.join([variable_name, 'es'])
@@ skipping 19 matching lines @@
     # of this differently, and we may wish to reconsider this approach
     null_check = 'WithNullCheck' \
         if null_check or allow_null(idl_type, interface_extended_attributes, extended_attributes) else ''
     return cpp_expression_format.format(null_check=null_check,
                                         arguments=arguments,
                                         index=index,
                                         idl_type=base_idl_type,
                                         auto_scope=DartUtilities.bool_to_cpp(auto_scope))
 
 
-def dart_value_to_cpp_value_array_or_sequence(array_or_sequence_type, variable_name, index):
+def dart_value_to_cpp_value_array_or_sequence(native_array_element_type, variable_name, index):
     # Index is None for setters, index (starting at 0) for method arguments,
     # 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 (array_or_sequence_type.is_interface_type and
-        array_or_sequence_type.name != 'Dictionary'):
-        this_cpp_type = array_or_sequence_type.cpp_type
-        ref_ptr_type = 'Member' if array_or_sequence_type.is_will_be_garbage_collected else 'RefPtr'
+    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)
         # FIXME(vsm): We're not using ref_ptr_type....
         expression_format = 'DartUtilities::toNativeVector<{cpp_type} >(args, {index}, {variable_name}, exception)'
-        add_includes_for_type(array_or_sequence_type)
+        add_includes_for_type(native_array_element_type)
     else:
         ref_ptr_type = None
-        this_cpp_type = array_or_sequence_type.cpp_type
+        this_cpp_type = native_array_element_type.cpp_type
         expression_format = 'DartUtilities::toNativeVector<{cpp_type}>(args, {index}, {variable_name}, exception)'
-    expression = expression_format.format(array_or_sequence_type=array_or_sequence_type.name,
+
+    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,
                                           variable_name=variable_name)
     return expression
 
-
 def dart_value_to_local_cpp_value(idl_type, interface_extended_attributes, extended_attributes,
                                   variable_name, null_check, index=None, auto_scope=True):
     """Returns an expression that converts a Dart value to a C++ value as a local value."""
     idl_type = idl_type.preprocessed_type
 
     cpp_value = dart_value_to_cpp_value(
         idl_type, interface_extended_attributes, extended_attributes,
         variable_name, null_check, index, auto_scope)
 
     return cpp_value
 
-IdlType.dart_value_to_local_cpp_value = dart_value_to_local_cpp_value
-IdlUnionType.dart_value_to_local_cpp_value = dart_value_to_local_cpp_value
+IdlTypeBase.dart_value_to_local_cpp_value = dart_value_to_local_cpp_value
+#IdlUnionType.dart_value_to_local_cpp_value = dart_value_to_local_cpp_value
 
 
 # Insure that we don't use C++ reserved names.  Today on default is a problem.
 def check_reserved_name(name):
     return 'default_value' if (name == 'default') else name
 
 
 ################################################################################
 # C++ -> V8
 ################################################################################
 
 def preprocess_idl_type(idl_type):
     if idl_type.is_enum:
         # Enumerations are internally DOMStrings
         return IdlType('DOMString')
     if (idl_type.name == 'Any' or idl_type.is_callback_function):
         return IdlType('ScriptValue')
     return idl_type
 
-IdlType.preprocessed_type = property(preprocess_idl_type)
+IdlTypeBase.preprocessed_type = property(preprocess_idl_type)
 IdlUnionType.preprocessed_type = property(preprocess_idl_type)
 
 
 def preprocess_idl_type_and_value(idl_type, cpp_value, extended_attributes):
     """Returns IDL type and value, with preliminary type conversions applied."""
     idl_type = idl_type.preprocessed_type
     if idl_type.name == 'Promise':
         idl_type = IdlType('ScriptValue')
     # FIXME(vsm): V8 maps 'long long' and 'unsigned long long' to double
     # as they are not representable in ECMAScript.  Should we do the same?
@@ skipping 13 matching lines @@
 def dart_conversion_type(idl_type, extended_attributes):
     """Returns Dart conversion type, adding any additional includes.
 
     The Dart conversion type is used to select the C++ -> Dart conversion function
     or setDart*ReturnValue function; it can be an idl_type, a cpp_type, or a
     separate name for the type of conversion (e.g., 'DOMWrapper').
     """
     extended_attributes = extended_attributes or {}
 
     # Composite types
-    array_or_sequence_type = idl_type.array_or_sequence_type
-    if array_or_sequence_type:
-        if array_or_sequence_type.is_interface_type:
-            add_includes_for_type(array_or_sequence_type)
+    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 or base_idl_type == 'long long':
         return 'int'
     if base_idl_type in CPP_UNSIGNED_TYPES or base_idl_type == 'unsigned long long':
         return 'unsigned'
     if base_idl_type == 'DOMString':
@@ skipping 16 matching lines @@
     # Typed arrays don't have special Dart* classes for Dart.
     if idl_type.is_typed_array_type:
         if base_idl_type == 'ArrayBuffer':
             return 'ArrayBuffer'
         else:
             return 'TypedList'
 
     # Pointer type
     return 'DOMWrapper'
 
-IdlType.dart_conversion_type = dart_conversion_type
+IdlTypeBase.dart_conversion_type = dart_conversion_type
 
 
 DART_SET_RETURN_VALUE = {
     'boolean': 'Dart_SetBooleanReturnValue(args, {cpp_value})',
     'int': 'DartUtilities::setDartIntegerReturnValue(args, {cpp_value})',
     'unsigned': 'DartUtilities::setDartUnsignedLongLongReturnValue(args, {cpp_value})',
     'DOMString': 'DartUtilities::setDartStringReturnValue(args, {cpp_value}, {auto_scope})',
     # FIXME(terry): Need to handle checking to byte values > 255 throwing exception.
     'ByteString': 'DartUtilities::setDartByteStringReturnValue(args, {cpp_value}, {auto_scope})',
     # FIXME(terry):  Need to make valid unicode; match UTF-16 to U+FFFD REPLACEMENT CHARACTER.
@@ skipping 46 matching lines @@
     this_dart_conversion_type = idl_type.dart_conversion_type(extended_attributes)
     # SetReturn-specific overrides
     if this_dart_conversion_type in ['Date', 'EventHandler', 'ScriptValue', 'SerializedScriptValue', 'array']:
         # Convert value to Dart and then use general Dart_SetReturnValue
         # FIXME(vsm): Why do we differ from V8 here? It doesn't have a
         # creation_context.
         creation_context = ''
         if this_dart_conversion_type == 'array':
             # FIXME: This is not right if the base type is a primitive, DOMString, etc.
             # What is the right check for base type?
-            if idl_type.base_type not in DART_TO_CPP_VALUE:
-                creation_context = '<Dart%s>' % idl_type.base_type
+            base_type = str(idl_type.element_type)
+            if base_type not in DART_TO_CPP_VALUE:
+                if base_type == 'None':
+                    raise Exception('Unknown base type for ' + str(idl_type))
+                creation_context = '<Dart%s>' % base_type
+            if idl_type.is_nullable:
+                creation_context = 'Nullable' + creation_context
 
         cpp_value = idl_type.cpp_value_to_dart_value(cpp_value, creation_context=creation_context,
                                                      extended_attributes=extended_attributes)
     if this_dart_conversion_type == 'DOMWrapper':
         this_dart_conversion_type = dom_wrapper_conversion_type()
 
     format_string = DART_SET_RETURN_VALUE[this_dart_conversion_type]
 
     if release:
         cpp_value = '%s.release()' % cpp_value
@@ skipping 16 matching lines @@
         # FIXME(vsm): Why do we use 'result' instead of cpp_value as V8?
         member_type.dart_set_return_value('result' + str(i),
                                         extended_attributes,
                                         script_wrappable,
                                         release and release[i],
                                         for_main_world,
                                         auto_scope)
             for i, member_type in
             enumerate(idl_type.member_types)]
 
-IdlType.dart_set_return_value = dart_set_return_value
+IdlTypeBase.dart_set_return_value = dart_set_return_value
 IdlUnionType.dart_set_return_value = dart_set_return_value_union
 
 IdlType.release = property(lambda self: self.is_interface_type)
 IdlUnionType.release = property(
     lambda self: [member_type.is_interface_type
                   for member_type in self.member_types])
 
 
 CPP_VALUE_TO_DART_VALUE = {
     # Built-in types
@@ skipping 24 matching lines @@
     """Returns an expression that converts a C++ value to a Dart value."""
     # the isolate parameter is needed for callback interfaces
     idl_type, cpp_value = preprocess_idl_type_and_value(idl_type, cpp_value, extended_attributes)
     this_dart_conversion_type = idl_type.dart_conversion_type(extended_attributes)
     format_string = CPP_VALUE_TO_DART_VALUE[this_dart_conversion_type]
     statement = format_string.format(
         cpp_value=cpp_value, creation_context=creation_context,
         idl_type=idl_type.base_type)
     return statement
 
-IdlType.cpp_value_to_dart_value = cpp_value_to_dart_value
+IdlTypeBase.cpp_value_to_dart_value = cpp_value_to_dart_value
 
 
 # Override idl_type.name to not suffix orNull to the name, in Dart we always
 # test for null e.g.,
 #
 #      bool isNull = false;
 #      TYPE* result = receiver->GETTER(isNull);
 #      if (isNull)
 #          return;
 #
 def dart_name(idl_type):
     """Return type name.
 
     http://heycam.github.io/webidl/#dfn-type-name
     """
     base_type = idl_type.base_type
     base_type_name = TYPE_NAMES.get(base_type, base_type)
-    if idl_type.is_array:
-        return base_type_name + 'Array'
-    if idl_type.is_sequence:
-        return base_type_name + 'Sequence'
+    if idl_type.native_array_element_type:
+        return idl_type.inner_name()
     return base_type_name
 
 IdlType.name = property(dart_name)
 IdlUnionType.name = property(dart_name)
 
 
 def typechecked_interface(extended_attributes):
     return ('TypeChecking' in extended_attributes and\
             DartUtilities.extended_attribute_value_contains(extended_attributes['TypeChecking'], 'Interface'))
 
@@ skipping 26 matching lines @@
     else:
         # This logic is implemented in the methods.cpp template in V8
         if (idl_type.is_nullable or
            (not typechecked_argument(idl_type, interface_extended_attributes, extended_attributes))):
             return True
 
         if extended_attributes.get('Default') == 'Undefined':
             return True
 
         return False