Typedefs and IDL file order between platforms could generated different files.

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
@@ skipping 366 matching lines @@
   DART_IDL = 'dart.idl'
 
   def __init__(self, ast, filename=None):
     IDLNode.__init__(self, ast)
     self.filename = filename
 
     filename_basename = os.path.basename(filename)
 
     # Report of union types mapped to any.
 
+    # Remember all the typedefs before we start walking the AST.  Some
+    # IDLs now have typedefs before interfaces.  So we need to remember
+    # to resolve the typedefs.
+    self.typeDefs = self._convert_all(ast, 'TypeDef', IDLTypeDef)
+    for typedefName in ast.typedefs:
+      typedef_type = ast.typedefs[typedefName]
+      # Ignore unions and dictionaries for now we just want normal typedefs to resolve our arguments/types.
+      if not(isinstance(typedef_type.idl_type, IdlUnionType)) and not(typedef_type.idl_type.base_type == 'Dictionary'):
+        _addTypedef(IDLTypeDef(typedef_type))
+
     self.interfaces = self._convert_all(ast, 'Interface', IDLInterface)
     self.dictionaries = self._convert_all(ast, 'Dictionary', IDLDictionary)
 
     is_blink = not(isinstance(ast, list)) and ast.__module__ == 'idl_definitions'
 
     if is_blink:
       # implements is handled by the interface merging step (see the function
       # merge_interface_dependencies).
       for interface in self.interfaces:
         blink_interface = ast.interfaces.get(interface.id)
@@ skipping 28 matching lines @@
             for implemented_name in implements:
               implement_statement = self._createImplementsStatement(implementor,
                                                                     implemented_name)
               self.implementsStatements.append(implement_statement)
           else:
             self.implementsStatements = []
     else:
       self.implementsStatements = self._convert_all(ast, 'ImplStmt',
         IDLImplementsStatement)
 
-    # No reason to handle typedef they're already aliased in Blink's AST.
-    self.typeDefs = [] if is_blink else self._convert_all(ast, 'TypeDef', IDLTypeDef)
-
-    # Hack to record typedefs that are unions.
+    # 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
-        _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 579 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