IDL: Prefer to extend IdlTypeBase instead of IdlType

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 21 matching lines @@
 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
+from idl_types import IdlTypeBase, IdlType, IdlUnionType
 import v8_attributes  # for IdlType.constructor_type_name
 from v8_globals import includes
 
 
 ################################################################################
 # V8-specific handling of IDL types
 ################################################################################
 
 NON_WRAPPER_TYPES = frozenset([
     'CompareHow',
@@ skipping 12 matching lines @@
     'Float64Array': ('double', 'v8::kExternalDoubleArray'),
     'Int8Array': ('signed char', 'v8::kExternalByteArray'),
     'Int16Array': ('short', 'v8::kExternalShortArray'),
     'Int32Array': ('int', 'v8::kExternalIntArray'),
     'Uint8Array': ('unsigned char', 'v8::kExternalUnsignedByteArray'),
     'Uint8ClampedArray': ('unsigned char', 'v8::kExternalPixelArray'),
     'Uint16Array': ('unsigned short', 'v8::kExternalUnsignedShortArray'),
     'Uint32Array': ('unsigned int', 'v8::kExternalUnsignedIntArray'),
 }
 
+IdlTypeBase.is_typed_array_element_type = False
 IdlType.is_typed_array_element_type = property(
     lambda self: self.base_type in TYPED_ARRAYS)
-IdlUnionType.is_typed_array_element_type = False
 
 
+IdlTypeBase.is_wrapper_type = False
 IdlType.is_wrapper_type = property(
     lambda self: (self.is_interface_type and
                   self.base_type not in NON_WRAPPER_TYPES))
 
 
 ################################################################################
 # C++ types
 ################################################################################
 
 CPP_TYPE_SAME_AS_IDL_TYPE = set([
@@ skipping 121 matching lines @@
 
 def cpp_type_union(idl_type, extended_attributes=None, raw_type=False):
     return (member_type.cpp_type for member_type in idl_type.member_types)
 
 
 def cpp_type_initializer_union(idl_type):
     return (member_type.cpp_type_initializer for member_type in idl_type.member_types)
 
 
 # Allow access as idl_type.cpp_type if no arguments
-IdlType.cpp_type = property(cpp_type)
-IdlType.cpp_type_initializer = property(cpp_type_initializer)
+IdlTypeBase.cpp_type = property(cpp_type)
+IdlTypeBase.cpp_type_initializer = property(cpp_type_initializer)
+IdlTypeBase.cpp_type_args = cpp_type
 IdlUnionType.cpp_type = property(cpp_type_union)
 IdlUnionType.cpp_type_initializer = property(cpp_type_initializer_union)
-IdlType.cpp_type_args = cpp_type
 IdlUnionType.cpp_type_args = cpp_type_union
 
 
 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)
@@ skipping 34 matching lines @@
 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')])
 
 
@@ skipping 57 matching lines @@
 
 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
-IdlUnionType.add_includes_for_type = add_includes_for_type
+IdlTypeBase.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))
 
 
 def impl_should_use_nullable_container(idl_type):
     return idl_type.native_array_element_type or idl_type.is_primitive_type
 
-IdlType.impl_should_use_nullable_container = property(
+IdlTypeBase.impl_should_use_nullable_container = property(
     impl_should_use_nullable_container)
 
 
 def impl_includes_for_type(idl_type, interfaces_info):
     includes_for_type = set()
     if idl_type.impl_should_use_nullable_container:
         includes_for_type.add('bindings/core/v8/Nullable.h')
 
     idl_type = idl_type.preprocessed_type
     native_array_element_type = idl_type.native_array_element_type
     if native_array_element_type:
         includes_for_type.update(impl_includes_for_type(
                 native_array_element_type, interfaces_info))
         includes_for_type.add('wtf/Vector.h')
 
     if idl_type.is_string_type:
         includes_for_type.add('wtf/text/WTFString.h')
     if idl_type.name in interfaces_info:
         interface_info = interfaces_info[idl_type.name]
         includes_for_type.add(interface_info['include_path'])
     return includes_for_type
 
-IdlType.impl_includes_for_type = impl_includes_for_type
+IdlTypeBase.impl_includes_for_type = impl_includes_for_type
 
 
 component_dir = {}
 
 
 def set_component_dirs(new_component_dirs):
     component_dir.update(new_component_dirs)
 
 
 ################################################################################
@@ skipping 123 matching lines @@
         if macro == 'TONATIVE_VOID_EXCEPTIONSTATE':
             args.append('ScriptState::current(%s)' % isolate)
 
     if declare_variable:
         args.insert(0, this_cpp_type)
     else:
         suffix += '_INTERNAL'
 
     return '%s(%s)' % (macro + suffix, ', '.join(args))
 
-
-IdlType.v8_value_to_local_cpp_value = v8_value_to_local_cpp_value
-IdlUnionType.v8_value_to_local_cpp_value = v8_value_to_local_cpp_value
+IdlTypeBase.v8_value_to_local_cpp_value = v8_value_to_local_cpp_value
 
 
 ################################################################################
 # 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)
-IdlUnionType.preprocessed_type = property(preprocess_idl_type)
+IdlTypeBase.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')
     if idl_type.base_type in ['long long', 'unsigned long long']:
         # long long and unsigned long long are not representable in ECMAScript;
         # we represent them as doubles.
@@ skipping 49 matching lines @@
         return base_idl_type
 
     # 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'
 
-IdlType.v8_conversion_type = v8_conversion_type
+IdlTypeBase.v8_conversion_type = v8_conversion_type
 
 
 V8_SET_RETURN_VALUE = {
     'boolean': 'v8SetReturnValueBool(info, {cpp_value})',
     'int': 'v8SetReturnValueInt(info, {cpp_value})',
     'unsigned': 'v8SetReturnValueUnsigned(info, {cpp_value})',
     'DOMString': 'v8SetReturnValueString(info, {cpp_value}, info.GetIsolate())',
     'ByteString': 'v8SetReturnValueString(info, {cpp_value}, info.GetIsolate())',
     'ScalarValueString': 'v8SetReturnValueString(info, {cpp_value}, info.GetIsolate())',
     # [TreatReturnedNullStringAs]
@@ skipping 55 matching lines @@
 
     return [
         member_type.v8_set_return_value(cpp_value + str(i),
                                         extended_attributes,
                                         script_wrappable,
                                         release and release[i],
                                         for_main_world)
             for i, member_type in
             enumerate(idl_type.member_types)]
 
-IdlType.v8_set_return_value = v8_set_return_value
+IdlTypeBase.v8_set_return_value = v8_set_return_value
 IdlUnionType.v8_set_return_value = v8_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_V8_VALUE = {
     # Built-in types
@@ skipping 24 matching lines @@
 
 def cpp_value_to_v8_value(idl_type, cpp_value, isolate='info.GetIsolate()', creation_context='info.Holder()', extended_attributes=None):
     """Returns an expression that converts a C++ value to a V8 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_v8_conversion_type = idl_type.v8_conversion_type(extended_attributes)
     format_string = CPP_VALUE_TO_V8_VALUE[this_v8_conversion_type]
     statement = format_string.format(cpp_value=cpp_value, isolate=isolate, creation_context=creation_context)
     return statement
 
-IdlType.cpp_value_to_v8_value = cpp_value_to_v8_value
+IdlTypeBase.cpp_value_to_v8_value = cpp_value_to_v8_value
 
 
 def literal_cpp_value(idl_type, idl_literal):
     """Converts an expression that is a valid C++ literal for this type."""
     # FIXME: add validation that idl_type and idl_literal are compatible
     literal_value = str(idl_literal)
     if idl_type.base_type in CPP_UNSIGNED_TYPES:
         return literal_value + 'u'
     return literal_value
 
@@ skipping 14 matching lines @@
     return idl_type.is_nullable and (
         (idl_type.is_string_type or idl_type.is_wrapper_type) and
         not idl_type.native_array_element_type)
 
 
 def is_explicit_nullable(idl_type):
     # Nullable type that isn't implicit nullable (see above.) For such types,
     # we use Nullable<T> or similar explicit ways to represent a null value.
     return idl_type.is_nullable and not idl_type.is_implicit_nullable
 
-IdlType.is_implicit_nullable = property(is_implicit_nullable)
-IdlType.is_explicit_nullable = property(is_explicit_nullable)
+IdlTypeBase.is_implicit_nullable = property(is_implicit_nullable)
 IdlUnionType.is_implicit_nullable = False
-IdlUnionType.is_explicit_nullable = property(is_explicit_nullable)
+IdlTypeBase.is_explicit_nullable = property(is_explicit_nullable)