Migrate to Chrome 37 IDL

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, IdlUnionType
@@ skipping 142 matching lines @@
           sub_res = self._find_all(childAst, label,
                        max_results - len(res))
           res.extend(sub_res)
     elif isinstance(ast, tuple):
       (nodeLabel, value) = ast
       if nodeLabel == label:
         res.append(value)
     # TODO(terry): Seems bogus to check for so many things probably better to just
     #              pass in blink_compile and drive it off from that...
     elif (ast and not(isinstance(ast, dict)) and
-          not(isinstance(ast, str)) and ast.__module__ == "idl_definitions"):
+          not(isinstance(ast, str)) and
+          (ast.__module__ == "idl_definitions" or ast.__module__ == "idl_types")):
       field_name = self._convert_label_to_field(label)
       if hasattr(ast, field_name):
         field_value = getattr(ast, field_name)
         if field_value:
           if label == 'Interface' or label == 'Enum':
             for key in field_value:
               value = field_value[key]
               res.append(value)
           elif isinstance(field_value, list):
             for item in field_value:
@@ skipping 189 matching lines @@
     self.interfaces = self._convert_all(ast, 'Interface', IDLInterface)
 
     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)
         if filename_basename == self.DART_IDL:
-          # TODO(terry): Does this seem right?
+          # Special handling for dart.idl we need to remember the interface,
+          # since we could have many (not one interface / file). Then build up
+          # the IDLImplementsStatement for any implements in dart.idl.
+          interface_info = interfaces_info['__dart_idl___'];
+
           self.implementsStatements = []
+
+          implement_pairs = interface_info['implement_pairs']
+          for implement_pair in implement_pairs:
+            interface_name = implement_pair[0]
+            implemented_name = implement_pair[1]
+
+            implementor = new_asts[interface_name].interfaces.get(interface_name)
+            implement_statement = self._createImplementsStatement(implementor,
+                                                                  implemented_name)
+
+            self.implementsStatements.append(implement_statement)
         else:
           interface_info = interfaces_info[interface.id]
 
           implements = interface_info['implements_interfaces']
           if not(blink_interface.is_partial) and len(implements) > 0:
             implementor = new_asts[interface.id].interfaces.get(interface.id)
 
             self.implementsStatements = []
 
             # TODO(terry): Need to handle more than one implements.
             for implemented_name in implements:
-              implemented = new_asts[implemented_name].interfaces.get(implemented_name)
-
-              implement_statement = IDLImplementsStatement(implemented)
-
-              implement_statement.implementor = IDLType(implementor)
-              implement_statement.implemented = IDLType(implemented)
-
+              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)
 
     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)
+
+    return implement_statement
+
 
 class IDLModule(IDLNode):
   """IDLModule has an id, and may contain interfaces, type defs and
   implements statements."""
   def __init__(self, ast):
     IDLNode.__init__(self, ast)
     self._convert_ext_attrs(ast)
     self._convert_annotations(ast)
     self.interfaces = self._convert_all(ast, 'Interface', IDLInterface)
 
@@ skipping 137 matching lines @@
         #              https://code.google.com/p/chromium/issues/detail?id=354298
         type_name = type_name.replace('unrestricted ', '', 1);
 
         # TODO(terry): Handled ScalarValueString as a DOMString.
         type_name = type_name.replace('ScalarValueString', 'DOMString', 1)
 
         self.id = type_name
       else:
         # IdlUnionType
         assert ast.is_union_type
-        self.id = self._label_to_type('UnionType', ast)
+        # TODO(terry): For union types use any otherwise type is unionType is
+        #              not found and is removed during merging.
+        self.id = 'any'
+        # TODO(terry): Any union type e.g. 'type1 or type2 or type2',
+        #                            'typedef (Type1 or Type2) UnionType'
+        # Is a problem we need to extend IDLType and IDLTypeDef to handle more
+        # than one type.
+        #
+        # Also for typedef's e.g.,
+        #                 typedef (Type1 or Type2) UnionType
+        # should consider synthesizing a new interface (e.g., UnionType) that's
+        # both Type1 and Type2.
     if not self.id:
       print '>>>> __module__ %s' % ast.__module__
       raise SyntaxError('Could not parse type %s' % (ast))
 
   def _label_to_type(self, label, ast):
     if label == 'LongLongType':
       label = 'long long'
     elif label.endswith('Type'):
       # Omit 'Type' suffix and lowercase the rest.
       label = '%s%s' % (label[0].lower(), label[1:-4])
@@ skipping 224 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