bindings: Drop |idl_name| from IdlDefinitions

third_party/WebKit/Source/bindings/scripts/idl_definitions.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 70 matching lines @@
     """
     __metaclass__ = abc.ABCMeta
     idl_type_attributes = ('idl_type',)
 
 
 ################################################################################
 # Definitions (main container class)
 ################################################################################
 
 class IdlDefinitions(object):
-    def __init__(self, idl_name, node):
+    def __init__(self, node):
         """Args: node: AST root node, class == 'File'"""
         self.callback_functions = {}
         self.dictionaries = {}
         self.enumerations = {}
         self.implements = []
         self.interfaces = {}
-        self.idl_name = idl_name
         self.typedefs = {}
 
         node_class = node.GetClass()
         if node_class != 'File':
             raise ValueError('Unrecognized node class: %s' % node_class)
 
         children = node.GetChildren()
         for child in children:
             child_class = child.GetClass()
             if child_class == 'Interface':
-                interface = IdlInterface(idl_name, child)
+                interface = IdlInterface(child)
                 self.interfaces[interface.name] = interface
             elif child_class == 'Exception':
-                exception = IdlException(idl_name, child)
+                exception = IdlException(child)
                 # For simplicity, treat exceptions as interfaces
                 self.interfaces[exception.name] = exception
             elif child_class == 'Typedef':
                 typedef = IdlTypedef(child)
                 self.typedefs[typedef.name] = typedef
             elif child_class == 'Enum':
-                enumeration = IdlEnum(idl_name, child)
+                enumeration = IdlEnum(child)
                 self.enumerations[enumeration.name] = enumeration
             elif child_class == 'Callback':
-                callback_function = IdlCallbackFunction(idl_name, child)
+                callback_function = IdlCallbackFunction(child)
                 self.callback_functions[callback_function.name] = callback_function
             elif child_class == 'Implements':
                 self.implements.append(IdlImplement(child))
             elif child_class == 'Dictionary':
-                dictionary = IdlDictionary(idl_name, child)
+                dictionary = IdlDictionary(child)
                 self.dictionaries[dictionary.name] = dictionary
             else:
                 raise ValueError('Unrecognized node class: %s' % child_class)
 
     def accept(self, visitor):
         visitor.visit_definitions(self)
         for interface in self.interfaces.itervalues():
             interface.accept(visitor)
         for callback_function in self.callback_functions.itervalues():
             callback_function.accept(visitor)
@@ skipping 25 matching lines @@
             # Merge callbacks and enumerations
             self.enumerations.update(other.enumerations)
             self.callback_functions.update(other.callback_functions)
 
 
 ################################################################################
 # Callback Functions
 ################################################################################
 
 class IdlCallbackFunction(TypedObject):
-    def __init__(self, idl_name, node):
+    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]
         arguments_node = children[1]
         if num_children == 3:
             ext_attributes_node = children[2]
             self.extended_attributes = (
-                ext_attributes_node_to_extended_attributes(idl_name, ext_attributes_node))
+                ext_attributes_node_to_extended_attributes(ext_attributes_node))
         else:
             self.extended_attributes = {}
         arguments_node_class = arguments_node.GetClass()
         if arguments_node_class != 'Arguments':
             raise ValueError('Expected Arguments node, got %s' % arguments_node_class)
 
-        self.idl_name = idl_name
         self.name = node.GetName()
         self.idl_type = type_node_to_type(type_node)
-        self.arguments = arguments_node_to_arguments(idl_name, arguments_node)
+        self.arguments = arguments_node_to_arguments(arguments_node)
 
     def accept(self, visitor):
         visitor.visit_callback_function(self)
         for argument in self.arguments:
             argument.accept(visitor)
 
 
 ################################################################################
 # Dictionary
 ################################################################################
 
 class IdlDictionary(object):
-    def __init__(self, idl_name, node):
+    def __init__(self, node):
         self.extended_attributes = {}
         self.is_partial = bool(node.GetProperty('Partial'))
-        self.idl_name = idl_name
         self.name = node.GetName()
         self.members = []
         self.parent = None
         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(idl_name, child))
+                self.members.append(IdlDictionaryMember(child))
             elif child_class == 'ExtAttributes':
                 self.extended_attributes = (
-                    ext_attributes_node_to_extended_attributes(idl_name, child))
+                    ext_attributes_node_to_extended_attributes(child))
             else:
                 raise ValueError('Unrecognized node class: %s' % child_class)
 
     def accept(self, visitor):
         visitor.visit_dictionary(self)
         for member in self.members:
             member.accept(visitor)
 
 
 class IdlDictionaryMember(TypedObject):
-    def __init__(self, idl_name, node):
+    def __init__(self, node):
         self.default_value = None
         self.extended_attributes = {}
         self.idl_type = None
-        self.idl_name = idl_name
         self.is_required = bool(node.GetProperty('REQUIRED'))
         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 = default_node_to_idl_literal(child)
             elif child_class == 'ExtAttributes':
                 self.extended_attributes = (
-                    ext_attributes_node_to_extended_attributes(idl_name, child))
+                    ext_attributes_node_to_extended_attributes(child))
             else:
                 raise ValueError('Unrecognized node class: %s' % child_class)
 
     def accept(self, visitor):
         visitor.visit_dictionary_member(self)
 
 
 ################################################################################
 # Enumerations
 ################################################################################
 
 class IdlEnum(object):
-    # FIXME: remove, just treat enums as a dictionary

[bashi, 2016/10/25 02:09:31]

We do want to represent an enum as a class instance :)

-    def __init__(self, idl_name, node):
-        self.idl_name = idl_name
+    def __init__(self, node):
         self.name = node.GetName()
         self.values = []
         for child in node.GetChildren():
             self.values.append(child.GetName())
 
     def accept(self, visitor):
         visitor.visit_enumeration(self)
 
 
 ################################################################################
 # Typedefs
 ################################################################################
 
 class IdlTypedef(object):
     idl_type_attributes = ('idl_type',)
 
     def __init__(self, node):
         self.name = node.GetName()
         self.idl_type = typedef_node_to_type(node)
 
     def accept(self, visitor):
         visitor.visit_typedef(self)
 
 
 ################################################################################
 # Interfaces and Exceptions
 ################################################################################
 
 class IdlInterface(object):
-    def __init__(self, idl_name, node=None):
+    def __init__(self, node=None):
         self.attributes = []
         self.constants = []
         self.constructors = []
         self.custom_constructors = []
         self.extended_attributes = {}
         self.operations = []
         self.parent = None
         self.serializer = None
         self.stringifier = None
         self.iterable = None
         self.has_indexed_elements = False
         self.maplike = None
         self.setlike = None
         self.original_interface = None
         self.partial_interfaces = []
         if not node:  # Early exit for IdlException.__init__
             return
 
         self.is_callback = bool(node.GetProperty('CALLBACK'))
         self.is_exception = False
         # FIXME: uppercase 'Partial' => 'PARTIAL' in base IDL parser
         self.is_partial = bool(node.GetProperty('Partial'))
-        self.idl_name = idl_name
         self.name = node.GetName()
         self.idl_type = IdlType(self.name)
 
         has_indexed_property_getter = False
         has_integer_typed_length = False
 
         children = node.GetChildren()
         for child in children:
             child_class = child.GetClass()
             if child_class == 'Attribute':
-                attr = IdlAttribute(idl_name, child)
+                attr = IdlAttribute(child)
                 if attr.idl_type.is_integer_type and attr.name == 'length':
                     has_integer_typed_length = True
                 self.attributes.append(attr)
             elif child_class == 'Const':
-                self.constants.append(IdlConstant(idl_name, child))
+                self.constants.append(IdlConstant(child))
             elif child_class == 'ExtAttributes':
-                extended_attributes = ext_attributes_node_to_extended_attributes(idl_name, child)
+                extended_attributes = ext_attributes_node_to_extended_attributes(child)
                 self.constructors, self.custom_constructors = (
-                    extended_attributes_to_constructors(idl_name, extended_attributes))
+                    extended_attributes_to_constructors(extended_attributes))
                 clear_constructor_attributes(extended_attributes)
                 self.extended_attributes = extended_attributes
             elif child_class == 'Operation':
-                op = IdlOperation(idl_name, child)
+                op = IdlOperation(child)
                 if 'getter' in op.specials and str(op.arguments[0].idl_type) == 'unsigned long':
                     has_indexed_property_getter = True
                 self.operations.append(op)
             elif child_class == 'Inherit':
                 self.parent = child.GetName()
             elif child_class == 'Serializer':
-                self.serializer = IdlSerializer(idl_name, child)
+                self.serializer = IdlSerializer(child)
                 self.process_serializer()
             elif child_class == 'Stringifier':
-                self.stringifier = IdlStringifier(idl_name, child)
+                self.stringifier = IdlStringifier(child)
                 self.process_stringifier()
             elif child_class == 'Iterable':
-                self.iterable = IdlIterable(idl_name, child)
+                self.iterable = IdlIterable(child)
             elif child_class == 'Maplike':
-                self.maplike = IdlMaplike(idl_name, child)
+                self.maplike = IdlMaplike(child)
             elif child_class == 'Setlike':
-                self.setlike = IdlSetlike(idl_name, child)
+                self.setlike = IdlSetlike(child)
             else:
                 raise ValueError('Unrecognized node class: %s' % child_class)
 
         if len(filter(None, [self.iterable, self.maplike, self.setlike])) > 1:
             raise ValueError('Interface can only have one of iterable<>, maplike<> and setlike<>.')
 
         if has_integer_typed_length and has_indexed_property_getter:
             self.has_indexed_elements = True
 
     def accept(self, visitor):
@@ skipping 40 matching lines @@
             self.stringifier = other.stringifier
 
 
 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, idl_name, node):
+    def __init__(self, node):
         # Exceptions are similar to Interfaces, but simpler
-        IdlInterface.__init__(self, idl_name)
+        IdlInterface.__init__(self)
         self.is_callback = False
         self.is_exception = True
         self.is_partial = False
-        self.idl_name = idl_name
         self.name = node.GetName()
         self.idl_type = IdlType(self.name)
 
         children = node.GetChildren()
         for child in children:
             child_class = child.GetClass()
             if child_class == 'Attribute':
-                attribute = IdlAttribute(idl_name, child)
+                attribute = IdlAttribute(child)
                 self.attributes.append(attribute)
             elif child_class == 'Const':
-                self.constants.append(IdlConstant(idl_name, child))
+                self.constants.append(IdlConstant(child))
             elif child_class == 'ExtAttributes':
-                extended_attributes = ext_attributes_node_to_extended_attributes(idl_name, child)
+                extended_attributes = ext_attributes_node_to_extended_attributes(child)
                 self.constructors, self.custom_constructors = (
-                    extended_attributes_to_constructors(idl_name, extended_attributes))
+                    extended_attributes_to_constructors(extended_attributes))
                 clear_constructor_attributes(extended_attributes)
                 self.extended_attributes = extended_attributes
             elif child_class == 'ExceptionOperation':
-                self.operations.append(IdlOperation.from_exception_operation_node(idl_name, child))
+                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, idl_name, node):
+    def __init__(self, node):
         self.is_read_only = bool(node.GetProperty('READONLY'))
         self.is_static = bool(node.GetProperty('STATIC'))
-        self.idl_name = idl_name
         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(idl_name, child)
+                self.extended_attributes = ext_attributes_node_to_extended_attributes(child)
             else:
                 raise ValueError('Unrecognized node class: %s' % child_class)
 
     def accept(self, visitor):
         visitor.visit_attribute(self)
 
 
 ################################################################################
 # Constants
 ################################################################################
 
 class IdlConstant(TypedObject):
-    def __init__(self, idl_name, node):
+    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.idl_name = idl_name
         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)
         # FIXME: This code is unnecessarily complicated due to the rather
         # inconsistent way the upstream IDL parser outputs default values.
         # http://crbug.com/374178
         if value_node.GetProperty('TYPE') == 'float':
             self.value = value_node.GetProperty('VALUE')
         else:
             self.value = value_node.GetName()
 
         if num_children == 3:
             ext_attributes_node = children[2]
-            self.extended_attributes = ext_attributes_node_to_extended_attributes(idl_name, ext_attributes_node)
+            self.extended_attributes = ext_attributes_node_to_extended_attributes(ext_attributes_node)
         else:
             self.extended_attributes = {}
 
     def accept(self, visitor):
         visitor.visit_constant(self)
 
 
 ################################################################################
 # Literals
 ################################################################################
@@ skipping 45 matching lines @@
     if idl_type == 'NULL':
         return IdlLiteralNull()
     raise ValueError('Unrecognized default value type: %s' % idl_type)
 
 
 ################################################################################
 # Operations
 ################################################################################
 
 class IdlOperation(TypedObject):
-    def __init__(self, idl_name, node=None):
+    def __init__(self, node=None):
         self.arguments = []
         self.extended_attributes = {}
         self.specials = []
         self.is_constructor = False
-        self.idl_name = idl_name
         self.idl_type = None
         self.is_static = False
 
         if not node:
             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 = bool(node.GetProperty('STATIC'))
         property_dictionary = node.GetProperties()
         for special_keyword in SPECIAL_KEYWORD_LIST:
             if special_keyword in property_dictionary:
                 self.specials.append(special_keyword.lower())
 
         children = node.GetChildren()
         for child in children:
             child_class = child.GetClass()
             if child_class == 'Arguments':
-                self.arguments = arguments_node_to_arguments(idl_name, child)
+                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(idl_name, child)
+                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, idl_name, node):
+    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(idl_name)
+        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(idl_name, ext_attributes_node)
+            operation.extended_attributes = ext_attributes_node_to_extended_attributes(ext_attributes_node)
 
         return operation
 
     @classmethod
-    def constructor_from_arguments_node(cls, name, idl_name, arguments_node):
-        constructor = cls(idl_name)
+    def constructor_from_arguments_node(cls, name, arguments_node):
+        constructor = cls()
         constructor.name = name
-        constructor.arguments = arguments_node_to_arguments(idl_name, arguments_node)
+        constructor.arguments = arguments_node_to_arguments(arguments_node)
         constructor.is_constructor = True
         return constructor
 
     def accept(self, visitor):
         visitor.visit_operation(self)
         for argument in self.arguments:
             argument.accept(visitor)
 
 
 ################################################################################
 # Arguments
 ################################################################################
 
 class IdlArgument(TypedObject):
-    def __init__(self, idl_name, node=None):
+    def __init__(self, node=None):
         self.extended_attributes = {}
         self.idl_type = None
         self.is_optional = False  # syntax: (optional T)
         self.is_variadic = False  # syntax: (T...)
-        self.idl_name = idl_name
         self.default_value = None
 
         if not node:
             return
 
         self.is_optional = node.GetProperty('OPTIONAL')
         self.name = node.GetName()
 
         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(idl_name, child)
+                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 = bool(child.GetProperty('ELLIPSIS'))
             elif child_class == 'Default':
                 self.default_value = default_node_to_idl_literal(child)
             else:
                 raise ValueError('Unrecognized node class: %s' % child_class)
 
     def accept(self, visitor):
         visitor.visit_argument(self)
 
 
-def arguments_node_to_arguments(idl_name, node):
+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(idl_name, argument_node)
-            for argument_node in node.GetChildren()]
+    return [IdlArgument(argument_node) for argument_node in node.GetChildren()]
 
 
 ################################################################################
 # Serializers
 ################################################################################
 
 class IdlSerializer(object):
-    def __init__(self, idl_name, node):
+    def __init__(self, node):
         self.attribute_name = node.GetProperty('ATTRIBUTE')
         self.attribute_names = None
         self.operation = None
         self.extended_attributes = {}
         self.is_attribute = False
         self.is_getter = False
         self.is_inherit = False
         self.is_list = False
         self.is_map = False
-        self.idl_name = idl_name
 
         for child in node.GetChildren():
             child_class = child.GetClass()
             if child_class == 'Operation':
-                self.operation = IdlOperation(idl_name, child)
+                self.operation = IdlOperation(child)
             elif child_class == 'List':
                 self.is_list = True
                 self.is_getter = bool(child.GetProperty('GETTER'))
                 self.attributes = child.GetProperty('ATTRIBUTES')
             elif child_class == 'Map':
                 self.is_map = True
                 self.is_attribute = bool(child.GetProperty('ATTRIBUTE'))
                 self.is_getter = bool(child.GetProperty('GETTER'))
                 self.is_inherit = bool(child.GetProperty('INHERIT'))
                 self.attributes = child.GetProperty('ATTRIBUTES')
             elif child_class == 'ExtAttributes':
-                self.extended_attributes = ext_attributes_node_to_extended_attributes(idl_name, child)
+                self.extended_attributes = ext_attributes_node_to_extended_attributes(child)
             else:
                 raise ValueError('Unrecognized node class: %s' % child_class)
 
 
 ################################################################################
 # Stringifiers
 ################################################################################
 
 class IdlStringifier(object):
-    def __init__(self, idl_name, node):
+    def __init__(self, node):
         self.attribute = None
         self.operation = None
         self.extended_attributes = {}
-        self.idl_name = idl_name
 
         for child in node.GetChildren():
             child_class = child.GetClass()
             if child_class == 'Attribute':
-                self.attribute = IdlAttribute(idl_name, child)
+                self.attribute = IdlAttribute(child)
             elif child_class == 'Operation':
-                operation = IdlOperation(idl_name, child)
+                operation = IdlOperation(child)
                 if operation.name:
                     self.operation = operation
             elif child_class == 'ExtAttributes':
-                self.extended_attributes = ext_attributes_node_to_extended_attributes(idl_name, child)
+                self.extended_attributes = ext_attributes_node_to_extended_attributes(child)
             else:
                 raise ValueError('Unrecognized node class: %s' % child_class)
 
         # Copy the stringifier's extended attributes (such as [Unforgable]) onto
         # the underlying attribute or operation, if there is one.
         if self.attribute or self.operation:
             (self.attribute or self.operation).extended_attributes.update(
                 self.extended_attributes)
 
 
 ################################################################################
 # Iterable, Maplike, Setlike
 ################################################################################
 
 class IdlIterableOrMaplikeOrSetlike(TypedObject):
-    def __init__(self, idl_name, node):
+    def __init__(self, node):
         self.extended_attributes = {}
         self.type_children = []
 
         for child in node.GetChildren():
             child_class = child.GetClass()
             if child_class == 'ExtAttributes':
-                self.extended_attributes = ext_attributes_node_to_extended_attributes(idl_name, child)
+                self.extended_attributes = ext_attributes_node_to_extended_attributes(child)
             elif child_class == 'Type':
                 self.type_children.append(child)
             else:
                 raise ValueError('Unrecognized node class: %s' % child_class)
 
 
 class IdlIterable(IdlIterableOrMaplikeOrSetlike):
     idl_type_attributes = ('key_type', 'value_type')
 
-    def __init__(self, idl_name, node):
-        super(IdlIterable, self).__init__(idl_name, node)
+    def __init__(self, node):
+        super(IdlIterable, self).__init__(node)
 
         if len(self.type_children) == 1:
             self.key_type = None
             self.value_type = type_node_to_type(self.type_children[0])
         elif len(self.type_children) == 2:
             self.key_type = type_node_to_type(self.type_children[0])
             self.value_type = type_node_to_type(self.type_children[1])
         else:
             raise ValueError('Unexpected number of type children: %d' % len(self.type_children))
         del self.type_children
 
     def accept(self, visitor):
         visitor.visit_iterable(self)
 
 
 class IdlMaplike(IdlIterableOrMaplikeOrSetlike):
     idl_type_attributes = ('key_type', 'value_type')
 
-    def __init__(self, idl_name, node):
-        super(IdlMaplike, self).__init__(idl_name, node)
+    def __init__(self, node):
+        super(IdlMaplike, self).__init__(node)
 
         self.is_read_only = bool(node.GetProperty('READONLY'))
 
         if len(self.type_children) == 2:
             self.key_type = type_node_to_type(self.type_children[0])
             self.value_type = type_node_to_type(self.type_children[1])
         else:
             raise ValueError('Unexpected number of children: %d' % len(self.type_children))
         del self.type_children
 
     def accept(self, visitor):
         visitor.visit_maplike(self)
 
 
 class IdlSetlike(IdlIterableOrMaplikeOrSetlike):
     idl_type_attributes = ('value_type',)
 
-    def __init__(self, idl_name, node):
-        super(IdlSetlike, self).__init__(idl_name, node)
+    def __init__(self, node):
+        super(IdlSetlike, self).__init__(node)
 
         self.is_read_only = bool(node.GetProperty('READONLY'))
 
         if len(self.type_children) == 1:
             self.value_type = type_node_to_type(self.type_children[0])
         else:
             raise ValueError('Unexpected number of children: %d' % len(self.type_children))
         del self.type_children
 
     def accept(self, visitor):
@@ skipping 21 matching lines @@
     """An Exposure holds one Exposed or RuntimeEnabled condition.
     Each exposure has two properties: exposed and runtime_enabled.
     Exposure(e, r) corresponds to [Exposed(e r)]. Exposure(e) corresponds to
     [Exposed=e].
     """
     def __init__(self, exposed, runtime_enabled=None):
         self.exposed = exposed
         self.runtime_enabled = runtime_enabled
 
 
-def ext_attributes_node_to_extended_attributes(idl_name, node):
+def ext_attributes_node_to_extended_attributes(node):
     """
     Returns:
       Dictionary of {ExtAttributeName: ExtAttributeValue}.
       Value is usually a string, with these 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.
@@ skipping 37 matching lines @@
                 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.')
             children = child.GetChildren()
             if len(children) != 1:
                 raise ValueError('[SetWrapperReferenceTo] supports only one child.')
             if child_class != 'Arguments':
                 raise ValueError('[SetWrapperReferenceTo] only supports Arguments as child, but has child of class: %s' % child_class)
-            extended_attributes[name] = IdlArgument(idl_name, children[0])
+            extended_attributes[name] = IdlArgument(children[0])
         elif name == 'Exposed':
             if child_class and child_class != 'Arguments':
                 raise ValueError('[Exposed] only supports Arguments as child, but has child of class: %s' % child_class)
             exposures = []
             if child_class == 'Arguments':
                 exposures = [Exposure(exposed=str(arg.idl_type),
                                       runtime_enabled=arg.name)
-                             for arg in arguments_node_to_arguments('*', child)]
+                             for arg in arguments_node_to_arguments(child)]
             else:
                 value = extended_attribute_node.GetProperty('VALUE')
                 if type(value) is str:
                     exposures = [Exposure(exposed=value)]
                 else:
                     exposures = [Exposure(exposed=v) for v in value]
             extended_attributes[name] = exposures
         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(idl_name, 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', idl_name, arguments_node)
+        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', idl_name, arguments_node)
+        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', idl_name, arguments_node)
+        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']
@@ skipping 135 matching lines @@
         self.visit_typed_object(argument)
 
     def visit_iterable(self, iterable):
         self.visit_typed_object(iterable)
 
     def visit_maplike(self, maplike):
         self.visit_typed_object(maplike)
 
     def visit_setlike(self, setlike):
         self.visit_typed_object(setlike)