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):
+        raise NotImplementedError(
+            '__str__() should be defined in subclasses')
 
-    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
-
-    @property
-    def inner_string(self):
-        raise NotImplementedError(
-            'inner_string property should be defined in subclasses')
-
-    @property
-    def is_basic_type(self):
-        return False
-
-    @property
-    def is_callback_function(self):
-        return False
-
-    @property
-    def is_callback_interface(self):
-        return False
-
-    @property
-    def is_dictionary(self):
-        return False
-
-    @property
-    def is_enum(self):
-        return False
-
-    @property
-    def is_integer_type(self):
-        return False
-
-    @property
-    def is_numeric_type(self):
-        return False
-
-    @property
-    def is_primitive_type(self):
-        return False
-
-    @property
-    def is_interface_type(self):
-        return False
-
-    @property
-    def is_string_type(self):
-        return False
-
-    @property
-    def is_union_type(self):
-        return False
-
-    @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')
+    def __getattr__(self, name):

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

Rather than hacky, how about considering this "elegant"?

Also, I think it's fine to just have this default to None, so this can be:
# Default undefined attributes to None (analogous to Jinja variables).
# This allows us to not define default properties in the base class,
# and allows us to relay __getattr__ in IdlNullableType to the inner type.
return None

This does lose us compile-time errors for typos (caught by test cases instead,
which is what we have for Jinja),
but removes the asymmetry of properties vs. member variables.

[Jens Widell, 2014/08/19 14:30:12]

Done. :-)

+        # This __getattr__() ensures that all properties supported by any of
+        # IdlType, IdlUnionType, IdlArrayOrSequenceType and IdlNullableType can
+        # be accessed without errors on any type object, but returns None if the
+        # actual type object doesn't support it.
+        #
+        # Note: This only applies to properties defined using the @property
+        # decorator, not properties set in __init__(); the latter form of
+        # property will only be accessible on objects of types that support it.
+        #
+        # We have this hack to avoid the need to explicitly support all
+        # properties on IdlNullableType, relaying the access to the inner type.
+        if not name.startswith('_'):

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

Do you need this?
__getattr__ is only called if an attribute is not found otherwise,
so this isn't overriding __str__, for instance.

(I appreciate the caution and desire for safety, but I'm not sure this actually
helps.)

[Jens Widell, 2014/08/19 14:30:12]

What I meant to avoid with this was Python looking for some __x__, expecting
either a valid value or an AttributeError. But I don't know that Python has any
problem with invalid values, and in my testing it doesn't seem like it does.

[Nils Barth (inactive), 2014/08/19 15:25:15]

Thanks for explaining; AFAICT Python doesn't need this:
it will use __ attributes if present (*not* calling __getattr__,
which is only used for usual attribute access, not the special
access of __ attributes), but otherwise proceed fine without;
details of course at:
https://docs.python.org/2/reference/datamodel.html

+            if (hasattr(IdlType, name) or
+                hasattr(IdlUnionType, name) or
+                hasattr(IdlArrayOrSequenceType, name) or
+                hasattr(IdlNullableType, name)):
+                return None
+        raise AttributeError(name)
 
     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 name(self):
+        return self.inner_type.name + 'OrNull'
+
+    def resolve_typedefs(self, typedefs):
+        self.inner_type = self.inner_type.resolve_typedefs(typedefs)
+        return self