IDL: Support iterable<>/maplike<>/setlike<> referencing typedefs

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 36 matching lines @@
         IdlLiteral
         IdlOperation < TypedObject
             IdlArgument < TypedObject
         IdlStringifier
         IdlIterable < IdlIterableOrMaplikeOrSetlike
         IdlMaplike < IdlIterableOrMaplikeOrSetlike
         IdlSetlike < IdlIterableOrMaplikeOrSetlike
     IdlException < IdlInterface
         (same contents as IdlInterface)
 
-TypedObject :: Object with a type.
+TypedObject :: Object with one or more attributes that is a type.
 
 IdlArgument is 'picklable', as it is stored in interfaces_info.
 
 Design doc: http://www.chromium.org/developers/design-documents/idl-compiler
 """
 
 import abc
 
 from idl_types import IdlType, IdlUnionType, IdlArrayType, IdlSequenceType, IdlNullableType
 
 SPECIAL_KEYWORD_LIST = ['GETTER', 'SETTER', 'DELETER']
 
 
 ################################################################################
 # TypedObject
 ################################################################################
 
 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
     by the TypedefResolver before passing data to the code generator.
     """
     __metaclass__ = abc.ABCMeta
-    idl_type = None
+    idl_type_attributes = ('idl_type',)
 
 
 ################################################################################
 # Definitions (main container class)
 ################################################################################
 
 class IdlDefinitions(object):
     def __init__(self, idl_name, node):
         """Args: node: AST root node, class == 'File'"""
         self.callback_functions = {}
@@ skipping 115 matching lines @@
                     ext_attributes_node_to_extended_attributes(idl_name, 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(object):
+class IdlDictionaryMember(TypedObject):
     def __init__(self, idl_name, node):
         self.default_value = None
         self.extended_attributes = {}
         self.idl_type = None
         self.idl_name = idl_name
         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)
@@ skipping 90 matching lines @@
         for attribute in self.attributes:
             attribute.accept(visitor)
         for constant in self.constants:
             constant.accept(visitor)
         for constructor in self.constructors:
             constructor.accept(visitor)
         for custom_constructor in self.custom_constructors:
             custom_constructor.accept(visitor)
         for operation in self.operations:
             operation.accept(visitor)
+        if self.iterable:

[bashi, 2015/02/12 12:36:19]

Question: Could a dictionary have a member which is an iterable? Same for
maplike and setlike.

[Jens Widell, 2015/02/12 12:47:51]

You can't have

  dictionary Foo {
    iterable<DOMString>;
  };

if that's what you mean. Only interfaces can have these declarations.

[bashi, 2015/02/12 13:08:19]

Oops, I just overlooked collapsed lines (L219-L318). I thought that line 329-334
were added in IdlDictionaryMember.accept(). Sorry for the noise.

+            self.iterable.accept(visitor)
+        elif self.maplike:
+            self.maplike.accept(visitor)
+        elif self.setlike:
+            self.setlike.accept(visitor)
 
     def process_stringifier(self):
         """Add the stringifier's attribute or named operation child, if it has
         one, as a regular attribute/operation of this interface."""
         if self.stringifier.attribute:
             self.attributes.append(self.stringifier.attribute)
         elif self.stringifier.operation:
             self.operations.append(self.stringifier.operation)
 
     def merge(self, other):
@@ skipping 160 matching lines @@
 # Operations
 ################################################################################
 
 class IdlOperation(TypedObject):
     def __init__(self, idl_name, 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())
 
-        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(idl_name, 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)
             else:
@@ skipping 121 matching lines @@
         # 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(object):
+class IdlIterableOrMaplikeOrSetlike(TypedObject):
     def __init__(self, idl_name, 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)
             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)
 
         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)
 
         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)
 
         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):
+        visitor.visit_setlike(self)
+
 
 ################################################################################
 # Implement statements
 ################################################################################
 
 class IdlImplement(object):
     def __init__(self, node):
         self.left_interface = node.GetName()
         self.right_interface = node.GetProperty('REFERENCE')
 
@@ skipping 224 matching lines @@
 ################################################################################
 # Visitor
 ################################################################################
 
 class Visitor(object):
     """Abstract visitor class for IDL definitions traverse."""
 
     def visit_definitions(self, definitions):
         pass
 
+    def visit_typed_object(self, typed_object):
+        pass
+
     def visit_callback_function(self, callback_function):
-        pass
+        self.visit_typed_object(callback_function)
 
     def visit_dictionary(self, dictionary):
         pass
 
     def visit_dictionary_member(self, member):
-        pass
+        self.visit_typed_object(member)
 
     def visit_interface(self, interface):
         pass
 
     def visit_attribute(self, attribute):
-        pass
+        self.visit_typed_object(attribute)
 
     def visit_constant(self, constant):
-        pass
+        self.visit_typed_object(constant)
 
     def visit_operation(self, operation):
-        pass
+        self.visit_typed_object(operation)
 
     def visit_argument(self, argument):
-        pass
+        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)