Migrated changed for sdk/lib genernation from integration branch to master

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 = {}
 
+# 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 = []
+
+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:
+    if typedef.id == type.id:
+      return typedef.type
+
+  return type
+
 
 _operation_suffix_map = {
   '__getter__': "Getter",
   '__setter__': "Setter",
   '__delete__': "Deleter",
 }
 
 class IDLNode(object):
   """Base class for all IDL elements.
   IDLNode may contain various child nodes, and have properties. Examples
@@ skipping 374 matching lines @@
     self.typeDefs = [] if is_blink else self._convert_all(ast, 'TypeDef', IDLTypeDef)
 
     # 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))
 
     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 322 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._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.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.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 31 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