Roll IDL to Dartium37 (r181268)

bindings/scripts/idl_definitions.py

Index: bindings/scripts/idl_definitions.py
diff --git a/bindings/scripts/idl_definitions.py b/bindings/scripts/idl_definitions.py
new file mode 100644
index 0000000000000000000000000000000000000000..50664ba12ef7addd5cb3cbc69484e0629231ba3d
--- /dev/null
+++ b/bindings/scripts/idl_definitions.py
@@ -0,0 +1,756 @@
+# 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
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Blink IDL Intermediate Representation (IR) classes.
+
+Classes are primarily constructors, which build an IdlDefinitions object
+(and various contained objects) from an AST (produced by blink_idl_parser).
+
+This is in two steps:
+* Constructors walk the AST, creating objects.
+* Typedef resolution.
+
+Typedefs are all resolved here, and not stored in IR.
+
+Typedef resolution uses some auxiliary classes and OOP techniques to make this
+a generic call, via the resolve_typedefs() method.
+
+Class hierarchy (mostly containment, '<' for inheritance):
+
+IdlDefinitions
+    IdlCallbackFunction < TypedObject
+    IdlEnum :: FIXME: remove, just use a dict for enums
+    IdlInterface
+        IdlAttribute < TypedObject
+        IdlConstant < TypedObject
+        IdlOperation < TypedObject
+            IdlArgument < TypedObject
+    IdlException < IdlInterface
+        (same contents as IdlInterface)
+
+TypedObject :: mixin for typedef resolution
+
+Design doc: http://www.chromium.org/developers/design-documents/idl-compiler
+"""
+
+import abc
+
+from idl_types import IdlType, IdlUnionType
+
+SPECIAL_KEYWORD_LIST = ['GETTER', 'SETTER', 'DELETER']
+STANDARD_TYPEDEFS = {
+    # http://www.w3.org/TR/WebIDL/#common-DOMTimeStamp
+    'DOMTimeStamp': 'unsigned long long',
+}
+
+
+################################################################################
+# TypedObject (mixin for typedef resolution)
+################################################################################
+
+class TypedObject(object):
+    """Object with a type, such as an Attribute or Operation (return value).
+
+    The type can be an actual type, or can be a typedef, which must be resolved
+    before passing data to the code generator.
+    """
+    __metaclass__ = abc.ABCMeta
+    idl_type = None
+
+    def resolve_typedefs(self, typedefs):
+        """Resolve typedefs to actual types in the object."""
+        # Constructors don't have their own return type, because it's the
+        # interface itself.
+        if not self.idl_type:
+            return
+        # Need to re-assign self.idl_type, not just mutate idl_type,
+        # since type(idl_type) may change.
+        self.idl_type = self.idl_type.resolve_typedefs(typedefs)
+
+
+################################################################################
+# Definitions (main container class)
+################################################################################
+
+class IdlDefinitions(object):
+    def __init__(self, node):
+        """Args: node: AST root node, class == 'File'"""
+        self.callback_functions = {}
+        self.dictionaries = {}
+        self.enumerations = {}
+        self.interfaces = {}
+
+        node_class = node.GetClass()
+        if node_class != 'File':
+            raise ValueError('Unrecognized node class: %s' % node_class)
+
+        typedefs = dict((typedef_name, IdlType(type_name))
+                        for typedef_name, type_name in
+                        STANDARD_TYPEDEFS.iteritems())
+
+        children = node.GetChildren()
+        for child in children:
+            child_class = child.GetClass()
+            if child_class == 'Interface':
+                interface = IdlInterface(child)
+                self.interfaces[interface.name] = interface
+            elif child_class == 'Exception':
+                exception = IdlException(child)
+                # For simplicity, treat exceptions as interfaces
+                self.interfaces[exception.name] = exception
+            elif child_class == 'Typedef':
+                type_name = child.GetName()
+                typedefs[type_name] = typedef_node_to_type(child)
+            elif child_class == 'Enum':
+                enumeration = IdlEnum(child)
+                self.enumerations[enumeration.name] = enumeration
+            elif child_class == 'Callback':
+                callback_function = IdlCallbackFunction(child)
+                self.callback_functions[callback_function.name] = callback_function
+            elif child_class == 'Implements':
+                # Implements is handled at the interface merging step
+                pass
+            elif child_class == 'Dictionary':
+                dictionary = IdlDictionary(child)
+                self.dictionaries[dictionary.name] = dictionary
+            else:
+                raise ValueError('Unrecognized node class: %s' % child_class)
+
+        # Typedefs are not stored in IR:
+        # Resolve typedefs with the actual types and then discard the Typedefs.
+        # http://www.w3.org/TR/WebIDL/#idl-typedefs
+        self.resolve_typedefs(typedefs)
+
+    def resolve_typedefs(self, typedefs):
+        for callback_function in self.callback_functions.itervalues():
+            callback_function.resolve_typedefs(typedefs)
+        for interface in self.interfaces.itervalues():
+            interface.resolve_typedefs(typedefs)
+
+    def update(self, other):
+        """Update with additional IdlDefinitions."""
+        for interface_name, new_interface in other.interfaces.iteritems():
+            if not new_interface.is_partial:
+                # Add as new interface
+                self.interfaces[interface_name] = new_interface
+                continue
+
+            # Merge partial to existing interface
+            try:
+                self.interfaces[interface_name].merge(new_interface)
+            except KeyError:
+                raise Exception('Tried to merge partial interface for {0}, '
+                                'but no existing interface by that name'
+                                .format(interface_name))
+
+            # Merge callbacks and enumerations
+            self.enumerations.update(other.enumerations)
+            self.callback_functions.update(other.callback_functions)
+
+
+################################################################################
+# Callback Functions
+################################################################################
+
+class IdlCallbackFunction(TypedObject):
+    def __init__(self, node):
+        children = node.GetChildren()
+        num_children = len(children)
+        if num_children != 2:
+            raise ValueError('Expected 2 children, got %s' % num_children)
+        type_node, arguments_node = children
+        arguments_node_class = arguments_node.GetClass()
+        if arguments_node_class != 'Arguments':
+            raise ValueError('Expected Arguments node, got %s' % arguments_node_class)
+
+        self.name = node.GetName()
+        self.idl_type = type_node_to_type(type_node)
+        self.arguments = arguments_node_to_arguments(arguments_node)
+
+    def resolve_typedefs(self, typedefs):
+        TypedObject.resolve_typedefs(self, typedefs)
+        for argument in self.arguments:
+            argument.resolve_typedefs(typedefs)
+
+
+################################################################################
+# Dictionary
+################################################################################
+
+class IdlDictionary(object):
+    def __init__(self, node):
+        self.parent = None
+        self.name = node.GetName()
+        self.members = []
+        for child in node.GetChildren():
+            child_class = child.GetClass()
+            if child_class == 'Inherit':
+                self.parent = child.GetName()
+            elif child_class == 'Key':
+                self.members.append(IdlDictionaryMember(child))
+            else:
+                raise ValueError('Unrecognized node class: %s' % child_class)
+
+
+class IdlDictionaryMember(object):
+    def __init__(self, node):
+        self.default_value = None
+        self.extended_attributes = {}
+        self.idl_type = None
+        self.name = node.GetName()
+        for child in node.GetChildren():
+            child_class = child.GetClass()
+            if child_class == 'Type':
+                self.idl_type = type_node_to_type(child)
+            elif child_class == 'Default':
+                self.default_value = child.GetProperty('VALUE')
+            elif child_class == 'ExtAttributes':
+                self.extended_attributes = ext_attributes_node_to_extended_attributes(child)
+            else:
+                raise ValueError('Unrecognized node class: %s' % child_class)
+
+
+################################################################################
+# Enumerations
+################################################################################
+
+class IdlEnum(object):
+    # FIXME: remove, just treat enums as a dictionary
+    def __init__(self, node):
+        self.name = node.GetName()
+        self.values = []
+        for child in node.GetChildren():
+            self.values.append(child.GetName())
+
+
+################################################################################
+# Interfaces and Exceptions
+################################################################################
+
+class IdlInterface(object):
+    def __init__(self, node=None):
+        self.attributes = []
+        self.constants = []
+        self.constructors = []
+        self.custom_constructors = []
+        self.extended_attributes = {}
+        self.operations = []
+        self.parent = None
+        if not node:  # Early exit for IdlException.__init__
+            return
+
+        self.is_callback = node.GetProperty('CALLBACK') or False
+        self.is_exception = False
+        # FIXME: uppercase 'Partial' => 'PARTIAL' in base IDL parser
+        self.is_partial = node.GetProperty('Partial') or False
+        self.name = node.GetName()
+
+        children = node.GetChildren()
+        for child in children:
+            child_class = child.GetClass()
+            if child_class == 'Attribute':
+                self.attributes.append(IdlAttribute(child))
+            elif child_class == 'Const':
+                self.constants.append(IdlConstant(child))
+            elif child_class == 'ExtAttributes':
+                extended_attributes = ext_attributes_node_to_extended_attributes(child)
+                self.constructors, self.custom_constructors = (
+                    extended_attributes_to_constructors(extended_attributes))
+                clear_constructor_attributes(extended_attributes)
+                self.extended_attributes = extended_attributes
+            elif child_class == 'Operation':
+                self.operations.append(IdlOperation(child))
+            elif child_class == 'Inherit':
+                self.parent = child.GetName()
+            else:
+                raise ValueError('Unrecognized node class: %s' % child_class)
+
+    def resolve_typedefs(self, typedefs):
+        for attribute in self.attributes:
+            attribute.resolve_typedefs(typedefs)
+        for constant in self.constants:
+            constant.resolve_typedefs(typedefs)
+        for constructor in self.constructors:
+            constructor.resolve_typedefs(typedefs)
+        for custom_constructor in self.custom_constructors:
+            custom_constructor.resolve_typedefs(typedefs)
+        for operation in self.operations:
+            operation.resolve_typedefs(typedefs)
+
+    def merge(self, other):
+        """Merge in another interface's members (e.g., partial interface)"""
+        self.attributes.extend(other.attributes)
+        self.constants.extend(other.constants)
+        self.operations.extend(other.operations)
+
+
+class IdlException(IdlInterface):
+    # Properly exceptions and interfaces are distinct, and thus should inherit a
+    # common base class (say, "IdlExceptionOrInterface").
+    # However, there is only one exception (DOMException), and new exceptions
+    # are not expected. Thus it is easier to implement exceptions as a
+    # restricted subclass of interfaces.
+    # http://www.w3.org/TR/WebIDL/#idl-exceptions
+    def __init__(self, node):
+        # Exceptions are similar to Interfaces, but simpler
+        IdlInterface.__init__(self)
+        self.is_callback = False
+        self.is_exception = True
+        self.is_partial = False
+        self.name = node.GetName()
+
+        children = node.GetChildren()
+        for child in children:
+            child_class = child.GetClass()
+            if child_class == 'Attribute':
+                attribute = IdlAttribute(child)
+                self.attributes.append(attribute)
+            elif child_class == 'Const':
+                self.constants.append(IdlConstant(child))
+            elif child_class == 'ExtAttributes':
+                self.extended_attributes = ext_attributes_node_to_extended_attributes(child)
+            elif child_class == 'ExceptionOperation':
+                self.operations.append(IdlOperation.from_exception_operation_node(child))
+            else:
+                raise ValueError('Unrecognized node class: %s' % child_class)
+
+
+################################################################################
+# Attributes
+################################################################################
+
+class IdlAttribute(TypedObject):
+    def __init__(self, node):
+        self.is_read_only = node.GetProperty('READONLY') or False
+        self.is_static = node.GetProperty('STATIC') or False
+        self.name = node.GetName()
+        # Defaults, overridden below
+        self.idl_type = None
+        self.extended_attributes = {}
+
+        children = node.GetChildren()
+        for child in children:
+            child_class = child.GetClass()
+            if child_class == 'Type':
+                self.idl_type = type_node_to_type(child)
+            elif child_class == 'ExtAttributes':
+                self.extended_attributes = ext_attributes_node_to_extended_attributes(child)
+            else:
+                raise ValueError('Unrecognized node class: %s' % child_class)
+
+
+################################################################################
+# Constants
+################################################################################
+
+class IdlConstant(TypedObject):
+    def __init__(self, node):
+        children = node.GetChildren()
+        num_children = len(children)
+        if num_children < 2 or num_children > 3:
+            raise ValueError('Expected 2 or 3 children, got %s' % num_children)
+        type_node = children[0]
+        value_node = children[1]
+        value_node_class = value_node.GetClass()
+        if value_node_class != 'Value':
+            raise ValueError('Expected Value node, got %s' % value_node_class)
+
+        self.name = node.GetName()
+        # ConstType is more limited than Type, so subtree is smaller and
+        # we don't use the full type_node_to_type function.
+        self.idl_type = type_node_inner_to_type(type_node)
+        self.value = value_node.GetName()
+
+        if num_children == 3:
+            ext_attributes_node = children[2]
+            self.extended_attributes = ext_attributes_node_to_extended_attributes(ext_attributes_node)
+        else:
+            self.extended_attributes = {}
+
+
+################################################################################
+# Literals
+################################################################################
+
+class IdlLiteral(object):
+    def __init__(self, idl_type, value):
+        self.idl_type = idl_type
+        self.value = value
+        self.is_null = False
+
+    def __str__(self):
+        if self.idl_type == 'DOMString':
+            return 'String("%s")' % self.value
+        if self.idl_type == 'integer':
+            return '%d' % self.value
+        if self.idl_type == 'float':
+            return '%g' % self.value
+        if self.idl_type == 'boolean':
+            return 'true' if self.value else 'false'
+        raise ValueError('Unsupported literal type: %s' % self.idl_type)
+
+
+class IdlLiteralNull(IdlLiteral):
+    def __init__(self):
+        self.idl_type = 'NULL'
+        self.value = None
+        self.is_null = True
+
+    def __str__(self):
+        return 'nullptr'
+
+
+def default_node_to_idl_literal(node):
+    # FIXME: This code is unnecessarily complicated due to the rather
+    # inconsistent way the upstream IDL parser outputs default values.
+    # http://crbug.com/374178
+    idl_type = node.GetProperty('TYPE')
+    if idl_type == 'DOMString':
+        value = node.GetProperty('NAME')
+        if '"' in value or '\\' in value:
+            raise ValueError('Unsupported string value: %r' % value)
+        return IdlLiteral(idl_type, value)
+    if idl_type == 'integer':
+        return IdlLiteral(idl_type, int(node.GetProperty('NAME')))
+    if idl_type == 'float':
+        return IdlLiteral(idl_type, float(node.GetProperty('VALUE')))
+    if idl_type == 'boolean':
+        return IdlLiteral(idl_type, node.GetProperty('VALUE'))
+    if idl_type == 'NULL':
+        return IdlLiteralNull()
+    raise ValueError('Unrecognized default value type: %s' % idl_type)
+
+
+################################################################################
+# Operations
+################################################################################
+
+class IdlOperation(TypedObject):
+    def __init__(self, node=None):
+        self.arguments = []
+        self.extended_attributes = {}
+        self.specials = []
+        self.is_constructor = False
+
+        if not node:
+            self.is_static = False
+            return
+        self.name = node.GetName()  # FIXME: should just be: or ''
+        # FIXME: AST should use None internally
+        if self.name == '_unnamed_':
+            self.name = ''
+
+        self.is_static = node.GetProperty('STATIC') or False
+        property_dictionary = node.GetProperties()
+        for special_keyword in SPECIAL_KEYWORD_LIST:
+            if special_keyword in property_dictionary:
+                self.specials.append(special_keyword.lower())
+
+        self.idl_type = None
+        children = node.GetChildren()
+        for child in children:
+            child_class = child.GetClass()
+            if child_class == 'Arguments':
+                self.arguments = arguments_node_to_arguments(child)
+            elif child_class == 'Type':
+                self.idl_type = type_node_to_type(child)
+            elif child_class == 'ExtAttributes':
+                self.extended_attributes = ext_attributes_node_to_extended_attributes(child)
+            else:
+                raise ValueError('Unrecognized node class: %s' % child_class)
+
+    @classmethod
+    def from_exception_operation_node(cls, node):
+        # Needed to handle one case in DOMException.idl:
+        # // Override in a Mozilla compatible format
+        # [NotEnumerable] DOMString toString();
+        # FIXME: can we remove this? replace with a stringifier?
+        operation = cls()
+        operation.name = node.GetName()
+        children = node.GetChildren()
+        if len(children) < 1 or len(children) > 2:
+            raise ValueError('ExceptionOperation node with %s children, expected 1 or 2' % len(children))
+
+        type_node = children[0]
+        operation.idl_type = type_node_to_type(type_node)
+
+        if len(children) > 1:
+            ext_attributes_node = children[1]
+            operation.extended_attributes = ext_attributes_node_to_extended_attributes(ext_attributes_node)
+
+        return operation
+
+    @classmethod
+    def constructor_from_arguments_node(cls, name, arguments_node):
+        constructor = cls()
+        constructor.name = name
+        constructor.arguments = arguments_node_to_arguments(arguments_node)
+        constructor.is_constructor = True
+        return constructor
+
+    def resolve_typedefs(self, typedefs):
+        TypedObject.resolve_typedefs(self, typedefs)
+        for argument in self.arguments:
+            argument.resolve_typedefs(typedefs)
+
+
+################################################################################
+# Arguments
+################################################################################
+
+class IdlArgument(TypedObject):
+    def __init__(self, node):
+        self.extended_attributes = {}
+        self.idl_type = None
+        self.is_optional = node.GetProperty('OPTIONAL')  # syntax: (optional T)
+        self.is_variadic = False  # syntax: (T...)
+        self.name = node.GetName()
+        self.default_value = None
+
+        children = node.GetChildren()
+        for child in children:
+            child_class = child.GetClass()
+            if child_class == 'Type':
+                self.idl_type = type_node_to_type(child)
+            elif child_class == 'ExtAttributes':
+                self.extended_attributes = ext_attributes_node_to_extended_attributes(child)
+            elif child_class == 'Argument':
+                child_name = child.GetName()
+                if child_name != '...':
+                    raise ValueError('Unrecognized Argument node; expected "...", got "%s"' % child_name)
+                self.is_variadic = child.GetProperty('ELLIPSIS') or False
+            elif child_class == 'Default':
+                self.default_value = default_node_to_idl_literal(child)
+            else:
+                raise ValueError('Unrecognized node class: %s' % child_class)
+
+
+def arguments_node_to_arguments(node):
+    # [Constructor] and [CustomConstructor] without arguments (the bare form)
+    # have None instead of an arguments node, but have the same meaning as using
+    # an empty argument list, [Constructor()], so special-case this.
+    # http://www.w3.org/TR/WebIDL/#Constructor
+    if node is None:
+        return []
+    return [IdlArgument(argument_node)
+            for argument_node in node.GetChildren()]
+
+
+################################################################################
+# Extended attributes
+################################################################################
+
+def ext_attributes_node_to_extended_attributes(node):
+    """
+    Returns:
+      Dictionary of {ExtAttributeName: ExtAttributeValue}.
+      Value is usually a string, with three exceptions:
+      Constructors: value is a list of Arguments nodes, corresponding to
+        possible signatures of the constructor.
+      CustomConstructors: value is a list of Arguments nodes, corresponding to
+        possible signatures of the custom constructor.
+      NamedConstructor: value is a Call node, corresponding to the single
+        signature of the named constructor.
+    """
+    # Primarily just make a dictionary from the children.
+    # The only complexity is handling various types of constructors:
+    # Constructors and Custom Constructors can have duplicate entries due to
+    # overloading, and thus are stored in temporary lists.
+    # However, Named Constructors cannot be overloaded, and thus do not have
+    # a list.
+    # FIXME: move Constructor logic into separate function, instead of modifying
+    #        extended attributes in-place.
+    constructors = []
+    custom_constructors = []
+    extended_attributes = {}
+
+    def child_node(extended_attribute_node):
+        children = extended_attribute_node.GetChildren()
+        if not children:
+            return None
+        if len(children) > 1:
+            raise ValueError('ExtAttributes node with %s children, expected at most 1' % len(children))
+        return children[0]
+
+    extended_attribute_node_list = node.GetChildren()
+    for extended_attribute_node in extended_attribute_node_list:
+        name = extended_attribute_node.GetName()
+        child = child_node(extended_attribute_node)
+        child_class = child and child.GetClass()
+        if name == 'Constructor':
+            if child_class and child_class != 'Arguments':
+                raise ValueError('Constructor only supports Arguments as child, but has child of class: %s' % child_class)
+            constructors.append(child)
+        elif name == 'CustomConstructor':
+            if child_class and child_class != 'Arguments':
+                raise ValueError('[CustomConstructor] only supports Arguments as child, but has child of class: %s' % child_class)
+            custom_constructors.append(child)
+        elif name == 'NamedConstructor':
+            if child_class and child_class != 'Call':
+                raise ValueError('[NamedConstructor] only supports Call as child, but has child of class: %s' % child_class)
+            extended_attributes[name] = child
+        elif name == 'SetWrapperReferenceTo':
+            if not child:
+                raise ValueError('[SetWrapperReferenceTo] requires a child, but has none.')
+            if child_class != 'Arguments':
+                raise ValueError('[SetWrapperReferenceTo] only supports Arguments as child, but has child of class: %s' % child_class)
+            extended_attributes[name] = arguments_node_to_arguments(child)
+        elif child:
+            raise ValueError('ExtAttributes node with unexpected children: %s' % name)
+        else:
+            value = extended_attribute_node.GetProperty('VALUE')
+            extended_attributes[name] = value
+
+    # Store constructors and custom constructors in special list attributes,
+    # which are deleted later. Note plural in key.
+    if constructors:
+        extended_attributes['Constructors'] = constructors
+    if custom_constructors:
+        extended_attributes['CustomConstructors'] = custom_constructors
+
+    return extended_attributes
+
+
+def extended_attributes_to_constructors(extended_attributes):
+    """Returns constructors and custom_constructors (lists of IdlOperations).
+
+    Auxiliary function for IdlInterface.__init__.
+    """
+
+    constructor_list = extended_attributes.get('Constructors', [])
+    constructors = [
+        IdlOperation.constructor_from_arguments_node('Constructor', arguments_node)
+        for arguments_node in constructor_list]
+
+    custom_constructor_list = extended_attributes.get('CustomConstructors', [])
+    custom_constructors = [
+        IdlOperation.constructor_from_arguments_node('CustomConstructor', arguments_node)
+        for arguments_node in custom_constructor_list]
+
+    if 'NamedConstructor' in extended_attributes:
+        # FIXME: support overloaded named constructors, and make homogeneous
+        name = 'NamedConstructor'
+        call_node = extended_attributes['NamedConstructor']
+        extended_attributes['NamedConstructor'] = call_node.GetName()
+        children = call_node.GetChildren()
+        if len(children) != 1:
+            raise ValueError('NamedConstructor node expects 1 child, got %s.' % len(children))
+        arguments_node = children[0]
+        named_constructor = IdlOperation.constructor_from_arguments_node('NamedConstructor', arguments_node)
+        # FIXME: should return named_constructor separately; appended for Perl
+        constructors.append(named_constructor)
+
+    return constructors, custom_constructors
+
+
+def clear_constructor_attributes(extended_attributes):
+    # Deletes Constructor*s* (plural), sets Constructor (singular)
+    if 'Constructors' in extended_attributes:
+        del extended_attributes['Constructors']
+        extended_attributes['Constructor'] = None
+    if 'CustomConstructors' in extended_attributes:
+        del extended_attributes['CustomConstructors']
+        extended_attributes['CustomConstructor'] = None
+
+
+################################################################################
+# Types
+################################################################################
+
+def type_node_to_type(node):
+    children = node.GetChildren()
+    if len(children) < 1 or len(children) > 2:
+        raise ValueError('Type node expects 1 or 2 children (type + optional array []), got %s (multi-dimensional arrays are not supported).' % len(children))
+
+    type_node_child = children[0]
+
+    if len(children) == 2:
+        array_node = children[1]
+        array_node_class = array_node.GetClass()
+        if array_node_class != 'Array':
+            raise ValueError('Expected Array node as TypeSuffix, got %s node.' % array_node_class)
+        # FIXME: use IdlArrayType instead of is_array, once have that
+        is_array = True
+    else:
+        is_array = False
+
+    is_nullable = node.GetProperty('NULLABLE') or False  # syntax: T?
+
+    return type_node_inner_to_type(type_node_child, is_array=is_array, is_nullable=is_nullable)
+
+
+def type_node_inner_to_type(node, is_array=False, is_nullable=False):
+    # FIXME: remove is_array and is_nullable once have IdlArrayType and IdlNullableType
+    node_class = node.GetClass()
+    # Note Type*r*ef, not Typedef, meaning the type is an identifier, thus
+    # either a typedef shorthand (but not a Typedef declaration itself) or an
+    # interface type. We do not distinguish these, and just use the type name.
+    if node_class in ['PrimitiveType', 'Typeref']:
+        # unrestricted syntax: unrestricted double | unrestricted float
+        is_unrestricted = node.GetProperty('UNRESTRICTED') or False
+        return IdlType(node.GetName(), is_array=is_array, is_nullable=is_nullable, is_unrestricted=is_unrestricted)
+    elif node_class == 'Any':
+        return IdlType('any', is_array=is_array, is_nullable=is_nullable)
+    elif node_class == 'Sequence':
+        if is_array:
+            raise ValueError('Arrays of sequences are not supported')
+        return sequence_node_to_type(node, is_nullable=is_nullable)
+    elif node_class == 'UnionType':
+        if is_array:
+            raise ValueError('Arrays of unions are not supported')
+        return union_type_node_to_idl_union_type(node, is_nullable=is_nullable)
+    raise ValueError('Unrecognized node class: %s' % node_class)
+
+
+def sequence_node_to_type(node, is_nullable=False):
+    children = node.GetChildren()
+    if len(children) != 1:
+        raise ValueError('Sequence node expects exactly 1 child, got %s' % len(children))
+    sequence_child = children[0]
+    sequence_child_class = sequence_child.GetClass()
+    if sequence_child_class != 'Type':
+        raise ValueError('Unrecognized node class: %s' % sequence_child_class)
+    element_type = type_node_to_type(sequence_child).base_type
+    return IdlType(element_type, is_sequence=True, is_nullable=is_nullable)
+
+
+def typedef_node_to_type(node):
+    children = node.GetChildren()
+    if len(children) != 1:
+        raise ValueError('Typedef node with %s children, expected 1' % len(children))
+    child = children[0]
+    child_class = child.GetClass()
+    if child_class != 'Type':
+        raise ValueError('Unrecognized node class: %s' % child_class)
+    return type_node_to_type(child)
+
+
+def union_type_node_to_idl_union_type(node, is_nullable=False):
+    member_types = [type_node_to_type(member_type_node)
+                    for member_type_node in node.GetChildren()]
+    return IdlUnionType(member_types, is_nullable=is_nullable)