Fixed typedef used globally in IDLs

tools/dom/scripts/idlnode.py

 #!/usr/bin/python
 # Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 import os
 import sys
 
 import idl_definitions
 from idl_types import IdlType, IdlNullableType, IdlUnionType, IdlArrayOrSequenceType
 import dependency
 
 new_asts = {}
 
 # Report of union types mapped to any.
 _unions_to_any = []
 
 def report_unions_to_any():
   global _unions_to_any
 
   warnings = []
   for union_id in sorted(_unions_to_any):
     warnings.append('Union type %s is mapped to \'any\'' % union_id)
 
   return warnings
 
 # Ugly but Chrome IDLs can reference typedefs in any IDL w/o an include.  So we
 # need to remember any typedef seen then alias any reference to a typedef.
-typeDefsFixup = []
+_typeDefsFixup = []
 
-def _resolveTypedef(type):
+def _addTypedef(typedef):
+  _typeDefsFixup.append(typedef)
+
+def resolveTypedef(type):
   """ Given a type if it's a known typedef (only typedef's that aren't union)
       are remembered for fixup.  typedefs that are union type are mapped to
       any so those we don't need to alias.  typedefs referenced in the file
       where the typedef was defined are automatically aliased to the real type.
       This resolves typedef where the declaration is in another IDL file.
   """
-  for typedef in typeDefsFixup:
+  for typedef in _typeDefsFixup:
     if typedef.id == type.id:
       return typedef.type
 
   return type
 
 
 _operation_suffix_map = {
   '__getter__': "Getter",
   '__setter__': "Setter",
   '__delete__': "Deleter",
@@ skipping 383 matching lines @@
     # Hack to record typedefs that are unions.
     for typedefName in ast.typedefs:
       typedef_type = ast.typedefs[typedefName]
       if isinstance(typedef_type.idl_type, IdlUnionType):
         self.typeDefs.append(IDLTypeDef(typedef_type))
       elif typedef_type.idl_type.base_type == 'Dictionary':
         dictionary = IDLDictionary(typedef_type, True)
         self.dictionaries.append(dictionary)
       else:
         # All other typedefs we record
-        typeDefsFixup.append(IDLTypeDef(typedef_type))
+        _addTypedef(IDLTypeDef(typedef_type))
 
     self.enums = self._convert_all(ast, 'Enum', IDLEnum)
 
   def _createImplementsStatement(self, implementor, implemented_name):
     implemented = new_asts[implemented_name].interfaces.get(implemented_name)
 
     implement_statement = IDLImplementsStatement(implemented)
 
     implement_statement.implementor = IDLType(implementor)
     implement_statement.implemented = IDLType(implemented)
@@ skipping 327 matching lines @@
     self.type = self._convert_first(ast, 'InterfaceType', IDLType)
 
 
 class IDLMember(IDLNode):
   """A base class for constants, attributes and operations."""
 
   def __init__(self, ast, doc_js_interface_name):
     IDLNode.__init__(self, ast)
 
     self.type = self._convert_first(ast, 'Type', IDLType)
-    self.type = _resolveTypedef(self.type)
+    self.type = resolveTypedef(self.type)
 
     self._convert_ext_attrs(ast)
     self._convert_annotations(ast)
     self.doc_js_interface_name = doc_js_interface_name
     # TODO(terry): Can eliminate Suppressed when we're only using blink parser.
     self.is_fc_suppressed = 'Suppressed' in self.ext_attrs or \
                             'DartSuppress' in self.ext_attrs
     self.is_static = self._has(ast, 'Static')
 
 class IDLOperation(IDLMember):
   """IDLNode specialization for 'type name(args)' declarations."""
   def __init__(self, ast, doc_js_interface_name):
     IDLMember.__init__(self, ast, doc_js_interface_name)
 
     self.type = self._convert_first(ast, 'ReturnType', IDLType)
-    self.type = _resolveTypedef(self.type)
+    self.type = resolveTypedef(self.type)
+
     self.arguments = self._convert_all(ast, 'Argument', IDLArgument)
     self.specials = self._find_all(ast, 'Special')
     # Special case: there are getters of the form
     # getter <ReturnType>(args).  For now force the name to be __getter__,
     # but it should be operator[] later.
     if self.id is None:
       if self.specials == ['getter']:
         if self.ext_attrs.get('Custom') == 'PropertyQuery':
           # Handling __propertyQuery__ the extended attribute is:
           # [Custom=PropertyQuery] getter boolean (DOMString name);
@@ skipping 57 matching lines @@
       if isinstance(ast.default_value, idl_definitions.IdlLiteral) and ast.default_value:
         self.default_value = ast.default_value.value
         self.default_value_is_null = ast.default_value.is_null
       elif 'Default' in ast.extended_attributes:
         # Work around [Default=Undefined] for arguments - only look in the model's
         # default_value
         self.default_value = ast.extended_attributes.get('Default')
         self.default_value_is_null = False
 
     self.type = self._convert_first(ast, 'Type', IDLType)
-    self.type = _resolveTypedef(self.type)
+    self.type = resolveTypedef(self.type)
 
     self.optional = self._has(ast, 'Optional')
     self._convert_ext_attrs(ast)
     # TODO(vsm): Recover this from the type instead.
     if 'Callback' in self.type.id:
       self.ext_attrs['Callback'] = None
 
   def __repr__(self):
     return '<IDLArgument(type = %s, id = %s)>' % (self.type, self.id)
 
@@ skipping 32 matching lines @@
   """IDLDictNode specialization for one annotation."""
   def __init__(self, ast=None):
     IDLDictNode.__init__(self, ast)
     self.id = None
     if not ast:
       return
     for arg in self._find_all(ast, 'AnnotationArg'):
       name = self._find_first(arg, 'Id')
       value = self._find_first(arg, 'AnnotationArgValue')
       self[name] = value