IDL: Defer typedef resolution

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 13 matching lines @@
 # 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.
+IR stores typedefs and they are resolved by the code generator.
 
 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
@@ skipping 54 matching lines @@
 
 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
+        self.typedefs = {}
 
         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(idl_name, child)
                 self.interfaces[interface.name] = interface
             elif child_class == 'Exception':
                 exception = IdlException(idl_name, 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)
+                self.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':
                 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.
+    def resolve_typedefs(self, typedefs):
+        # Resolve typedefs with the actual types.
         # http://www.w3.org/TR/WebIDL/#idl-typedefs
-        self.resolve_typedefs(typedefs)
-
-    def resolve_typedefs(self, typedefs):
+        typedefs.update(dict((typedef_name, IdlType(type_name))
+                        for typedef_name, type_name in
+                        STANDARD_TYPEDEFS.iteritems()))
         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
@@ skipping 676 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)