IDL: Use IdlReader to compute interface_info_individual

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 39 matching lines @@
         IdlConstant < TypedObject
         IdlLiteral
         IdlOperation < TypedObject
             IdlArgument < TypedObject
         IdlStringifier
     IdlException < IdlInterface
         (same contents as IdlInterface)
 
 TypedObject :: mixin for typedef resolution
 
+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']
 STANDARD_TYPEDEFS = {
     # http://www.w3.org/TR/WebIDL/#common-DOMTimeStamp
@@ skipping 28 matching lines @@
 ################################################################################
 # Definitions (main container class)
 ################################################################################
 
 class IdlDefinitions(object):
     def __init__(self, idl_name, node):
         """Args: node: AST root node, class == 'File'"""
         self.callback_functions = {}
         self.dictionaries = {}
         self.enumerations = {}
+        self.implements = []
         self.interfaces = {}
         self.idl_name = idl_name
 
         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())
@@ skipping 11 matching lines @@
             elif child_class == 'Typedef':
                 type_name = child.GetName()
                 typedefs[type_name] = typedef_node_to_type(child)
             elif child_class == 'Enum':
                 enumeration = IdlEnum(idl_name, child)
                 self.enumerations[enumeration.name] = enumeration
             elif child_class == 'Callback':
                 callback_function = IdlCallbackFunction(idl_name, child)
                 self.callback_functions[callback_function.name] = callback_function
             elif child_class == 'Implements':
-                # Implements is handled at the interface merging step
-                pass
+                self.implements.append(IdlImplement(child))
             elif child_class == 'Dictionary':
                 dictionary = IdlDictionary(idl_name, 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)
@@ skipping 430 matching lines @@
             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 __getstate__(self):
+        # FIXME: Return a picklable object which has enough information to
+        # unpickle.
+        return {}
+
+    def __setstate__(self, state):
+        pass
+
 
 def arguments_node_to_arguments(idl_name, 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()]
@@ skipping 24 matching lines @@
                 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)
 
 
 ################################################################################
+# Implement statements
+################################################################################
+
+class IdlImplement(object):
+    def __init__(self, node):
+        self.left_interface = node.GetName()
+        self.right_interface = node.GetProperty('REFERENCE')
+
+
+################################################################################
 # Extended attributes
 ################################################################################
 
 def ext_attributes_node_to_extended_attributes(idl_name, 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.
@@ skipping 174 matching lines @@
     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):
     member_types = [type_node_to_type(member_type_node)
                     for member_type_node in node.GetChildren()]
     return IdlUnionType(member_types)