IDL: Use IdlNullableType wrapper to represent nullable types

Source/bindings/scripts/idl_types.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 """IDL type handling.
 
 Classes:
 IdlTypeBase
  IdlType
  IdlUnionType
  IdlArrayOrSequenceType
   IdlArrayType
   IdlSequenceType
+ IdlNullableType
 """
 
 from collections import defaultdict
 
 
 ################################################################################
 # IDL types
 ################################################################################
 
 INTEGER_TYPES = frozenset([
@@ skipping 71 matching lines @@
             ancestor_name in ancestors[interface_name])
 
 
 def set_ancestors(new_ancestors):
     ancestors.update(new_ancestors)
 
 
 class IdlTypeBase(object):
     """Base class for IdlType, IdlUnionType and IdlArrayOrSequenceType."""
 
-    def __init__(self, is_nullable):
-        self.base_type = None
-        self.is_nullable = is_nullable
-
     def __str__(self):
-        inner_string = self.inner_string
-        if self.is_nullable:
-            # FIXME: Dictionary::ConversionContext::setConversionType can't
-            # handle the '?' in nullable types (passes nullability separately).
-            # Update that function to handle nullability from the type name,
-            # simplifying its signature.
-            # return inner_string + '?'
-            return inner_string
-        return inner_string
+        raise NotImplementedError(
+            '__str__() should be defined in subclasses')
 
     @property
-    def inner_string(self):
-        raise NotImplementedError(
-            'inner_string property should be defined in subclasses')
+    def is_nullable(self):
+        return False
 
     @property
     def is_basic_type(self):
         return False
 
     @property
     def is_callback_function(self):
         return False
 
     @property
@@ skipping 26 matching lines @@
 
     @property
     def is_string_type(self):
         return False
 
     @property
     def is_union_type(self):
         return False
 
     @property
+    def base_type(self):
+        return None
+
+    @property
     def may_raise_exception_on_conversion(self):
         return False
 
     @property
     def name(self):
-        if self.is_nullable:
-            return self.inner_name + 'OrNull'
-        return self.inner_name
-
-    @property
-    def inner_name(self):
         raise NotImplementedError(
-            'inner_name property should be defined in subclasses')
+            'name property should be defined in subclasses')
 
     def resolve_typedefs(self, typedefs):
         raise NotImplementedError(
             'resolve_typedefs should be defined in subclasses')
 
 
 ################################################################################
 # IdlType
 ################################################################################
 
 class IdlType(IdlTypeBase):
     # FIXME: incorporate Nullable, etc.
     # to support types like short?[] vs. short[]?, instead of treating these
     # as orthogonal properties (via flags).
     callback_functions = set()
     callback_interfaces = set()
     dictionaries = set()
     enums = {}  # name -> values
 
-    def __init__(self, base_type, is_nullable=False, is_unrestricted=False):
-        super(IdlType, self).__init__(is_nullable)
+    def __init__(self, base_type, is_unrestricted=False):
+        super(IdlType, self).__init__()
         if is_unrestricted:
-            self.base_type = 'unrestricted %s' % base_type
+            self.base_type_name = 'unrestricted %s' % base_type
         else:
-            self.base_type = base_type
+            self.base_type_name = base_type
 
-    @property
-    def inner_string(self):
+    def __str__(self):
         return self.base_type
 
     @property
     def is_basic_type(self):
         return self.base_type in BASIC_TYPES
 
     @property
     def is_callback_function(self):
         return self.base_type in IdlType.callback_functions
 
@@ skipping 36 matching lines @@
         return not(self.is_basic_type or
                    self.is_callback_function or
                    self.is_dictionary or
                    self.is_enum or
                    self.name == 'Any' or
                    self.name == 'Object' or
                    self.name == 'Promise')  # Promise will be basic in future
 
     @property
     def is_string_type(self):
-        return self.inner_name in STRING_TYPES
+        return self.name in STRING_TYPES
 
     @property
     def may_raise_exception_on_conversion(self):
         return (self.is_integer_type or
                 self.name in ('ByteString', 'ScalarValueString'))
 
     @property
     def is_union_type(self):
         return isinstance(self, IdlUnionType)
 
     @property
-    def inner_name(self):
-        """Return type name (or inner type name if nullable)
+    def base_type(self):
+        return self.base_type_name
+
+    @property
+    def name(self):
+        """Return type name
 
         http://heycam.github.io/webidl/#dfn-type-name
         """
         base_type = self.base_type
         return TYPE_NAMES.get(base_type, base_type)
 
     @classmethod
     def set_callback_functions(cls, new_callback_functions):
         cls.callback_functions.update(new_callback_functions)
 
     @classmethod
     def set_callback_interfaces(cls, new_callback_interfaces):
         cls.callback_interfaces.update(new_callback_interfaces)
 
     @classmethod
     def set_dictionaries(cls, new_dictionaries):
         cls.dictionaries.update(new_dictionaries)
 
     @classmethod
     def set_enums(cls, new_enums):
         cls.enums.update(new_enums)
 
     def resolve_typedefs(self, typedefs):
-        # This function either returns |self|, possibly mutated, or leaves this
-        # object unmodified and returns a different object.
-        # FIXME: Change to never mutate |self|, and rename typedefs_resolved().
-        if self.base_type not in typedefs:
-            return self
-        new_type = typedefs[self.base_type]
-        if type(new_type) != type(self):
-            # If type changes, need to return a different object,
-            # since can't change type(self)
-            return new_type
-        # If type doesn't change, just mutate self to avoid a new object
-        self.__init__(new_type.base_type, self.is_nullable or new_type.is_nullable)
-        return self
+        # This function either returns |self| or a different object.
+        # FIXME: Rename typedefs_resolved().
+        return typedefs.get(self.base_type, self)
 
 
 ################################################################################
 # IdlUnionType
 ################################################################################
 
 class IdlUnionType(IdlTypeBase):
     # http://heycam.github.io/webidl/#idl-union
-    def __init__(self, member_types, is_nullable=False):
-        super(IdlUnionType, self).__init__(is_nullable=is_nullable)
+    def __init__(self, member_types):
+        super(IdlUnionType, self).__init__()
         self.member_types = member_types
 
     @property
     def is_union_type(self):
         return True
 
     @property
-    def inner_name(self):
+    def name(self):
         """Return type name (or inner type name if nullable)
 
         http://heycam.github.io/webidl/#dfn-type-name
         """
         return 'Or'.join(member_type.name for member_type in self.member_types)
 
     def resolve_typedefs(self, typedefs):
         self.member_types = [
             typedefs.get(member_type, member_type)
             for member_type in self.member_types]
         return self
 
 
 ################################################################################
 # IdlArrayOrSequenceType, IdlArrayType, IdlSequenceType
 ################################################################################
 
 class IdlArrayOrSequenceType(IdlTypeBase):
     """Base class for IdlArrayType and IdlSequenceType."""
 
-    def __init__(self, element_type, is_nullable=False):
-        super(IdlArrayOrSequenceType, self).__init__(is_nullable)
+    def __init__(self, element_type):
+        super(IdlArrayOrSequenceType, self).__init__()
         self.element_type = element_type
 
     def resolve_typedefs(self, typedefs):
         self.element_type = self.element_type.resolve_typedefs(typedefs)
         return self
 
 
 class IdlArrayType(IdlArrayOrSequenceType):
-    def __init__(self, element_type, is_nullable=False):
-        super(IdlArrayType, self).__init__(element_type, is_nullable)
+    def __init__(self, element_type):
+        super(IdlArrayType, self).__init__(element_type)
 
-    @property
-    def inner_string(self):
+    def __str__(self):
         return '%s[]' % self.element_type
 
     @property
-    def inner_name(self):
+    def name(self):
         return self.element_type.name + 'Array'
 
 
 class IdlSequenceType(IdlArrayOrSequenceType):
-    def __init__(self, element_type, is_nullable=False):
-        super(IdlSequenceType, self).__init__(element_type, is_nullable)
+    def __init__(self, element_type):
+        super(IdlSequenceType, self).__init__(element_type)
 
-    @property
-    def inner_string(self):
+    def __str__(self):
         return 'sequence<%s>' % self.element_type
 
     @property
-    def inner_name(self):
+    def name(self):
         return self.element_type.name + 'Sequence'
+
+
+################################################################################
+# IdlNullableType
+################################################################################
+
+class IdlNullableType(IdlTypeBase):
+    def __init__(self, inner_type):
+        super(IdlNullableType, self).__init__()
+        self.inner_type = inner_type
+
+    def __str__(self):
+        # FIXME: Dictionary::ConversionContext::setConversionType can't
+        # handle the '?' in nullable types (passes nullability separately).
+        # Update that function to handle nullability from the type name,
+        # simplifying its signature.
+        # return str(self.inner_type) + '?'
+        return str(self.inner_type)
+
+    def __getattr__(self, name):
+        return getattr(self.inner_type, name)
+
+    @property
+    def is_nullable(self):
+        return True
+
+    @property
+    def is_basic_type(self):
+        return self.inner_type.is_basic_type

[haraken, 2014/08/15 07:43:57]

Just a question about Python: Even if we have the above __getattr__, do we need
to define is_basic_type, is_callback_function etc?

[Jens Widell, 2014/08/15 08:00:09]

Yes, __getattr__ is called as a last resort, if the attribute wasn't found by
any other lookup mechanism. Thus we need to explicitly override everything that
IdlTypeBase defines.

If we didn't inherit IdlTypeBase, we could have just __getattr__, but then
extending IdlTypeBase in v8_types.py would no longer work.

[haraken, 2014/08/15 08:11:07]

Makes sense.

+
+    @property
+    def is_callback_function(self):
+        return self.inner_type.is_callback_function
+
+    @property
+    def is_callback_interface(self):
+        return self.inner_type.is_callback_interface
+
+    @property
+    def is_dictionary(self):
+        return self.inner_type.is_dictionary
+
+    @property
+    def is_enum(self):
+        return self.inner_type.is_enum
+
+    @property
+    def is_integer_type(self):
+        return self.inner_type.is_integer_type
+
+    @property
+    def is_numeric_type(self):
+        return self.inner_type.is_numeric_type
+
+    @property
+    def is_primitive_type(self):
+        return self.inner_type.is_primitive_type
+
+    @property
+    def is_interface_type(self):
+        return self.inner_type.is_interface_type
+
+    @property
+    def is_string_type(self):
+        return self.inner_type.is_string_type
+
+    @property
+    def is_union_type(self):
+        return self.inner_type.is_union_type
+
+    @property
+    def base_type(self):
+        return self.inner_type.base_type
+
+    @property
+    def may_raise_exception_on_conversion(self):
+        return self.inner_type.may_raise_exception_on_conversion
+
+    @property
+    def name(self):
+        return self.inner_type.name + 'OrNull'
+
+    def resolve_typedefs(self, typedefs):
+        self.inner_type = self.inner_type.resolve_typedefs(typedefs)
+        return self