Dartium 45 roll

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
-
-from compute_interfaces_info_overall import interfaces_info
-
+import dependency
 
 new_asts = {}
 
 
 _operation_suffix_map = {
   '__getter__': "Getter",
   '__setter__': "Setter",
   '__delete__': "Deleter",
 }
 
@@ skipping 332 matching lines @@
 
     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:
           # 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___'];
+          interface_info = dependency.get_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)
-        elif interface.id in interfaces_info:
-          interface_info = interfaces_info[interface.id]
+        elif interface.id in dependency.get_interfaces_info():
+          interface_info = dependency.get_interfaces_info()[interface.id]
 
-          implements = interface_info['implements_interfaces']
+          implements = interface_info['implements_interfaces'] if interface_info.has_key('implements_interfaces') else []
           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:
               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.
+    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)
+
     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 13 matching lines @@
 
     # 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', IDLNode)
 
     if is_blink:
       # implements is handled by the interface merging step (see the function
       # merge_interface_dependencies).
       for interface in self.interfaces:
-        interface_info = interfaces_info[interface.id]
+        interface_info = get_interfaces_info()[interface.id]
         # TODO(terry): Same handling for implementsStatements as in IDLFile?
         self.implementsStatements = interface_info['implements_interfaces']
     else:
       self.implementsStatements = self._convert_all(ast, 'ImplStmt',
         IDLImplementsStatement)
 
 
 class IDLExtAttrs(IDLDictNode):
   """IDLExtAttrs is an IDLDictNode that stores IDL Extended Attributes.
   Modules, interfaces, members and arguments can all own IDLExtAttrs."""
@@ skipping 113 matching lines @@
         self.id = value
       else:
         self.id = self._label_to_type(label, ast)
     elif isinstance(ast, str):
       self.id = ast
     # New blink handling.
     elif ast.__module__ == "idl_types":
       if isinstance(ast, IdlType) or isinstance(ast, IdlArrayOrSequenceType) or \
          isinstance(ast, IdlNullableType):
         type_name = str(ast)
-
         # TODO(terry): For now don't handle unrestricted types see
         #              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)
+        # TODO(terry): Handled USVString as a DOMString.
+        type_name = type_name.replace('USVString', 'DOMString', 1)
 
         self.id = type_name
       else:
         # IdlUnionType
         if ast.is_union_type:
           print 'WARNING type %s is union mapped to \'any\'' % self.id
         # 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',
@@ skipping 41 matching lines @@
   def __init__(self, ast):
     IDLNode.__init__(self, ast)
     self._convert_annotations(ast)
     self.type = self._convert_first(ast, 'Type', IDLType)
 
 
 class IDLDictionary(IDLNode):
   """IDLDictionary node contains members,
   as well as parent references."""
 
-  def __init__(self, ast):
+  def __init__(self, ast, typedefDictionary=False):
     IDLNode.__init__(self, ast)
 
     self.javascript_binding_name = self.id
-    self._convert_ext_attrs(ast)
-    self._convert_constants(ast, self.id)
-
+    if (typedefDictionary):
+        # Dictionary is a typedef to a union.
+        self._convert_ext_attrs(None)
+    else:
+        self._convert_ext_attrs(ast)
+        self._convert_constants(ast, self.id)
 
 class IDLDictionaryMembers(IDLDictNode):
   """IDLDictionaryMembers specialization for a list of FremontCut dictionary values."""
   def __init__(self, ast=None, js_name=None):
     IDLDictNode.__init__(self, ast)
     self.id = None
     if not ast:
       return
     for member in self._find_all(ast, 'Member'):
       name = self._find_first(member, 'Id')
@@ skipping 92 matching lines @@
     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);
           self.id = '__propertyQuery__'
+        elif self.ext_attrs.get('ImplementedAs'):
+          self.id = self.ext_attrs.get('ImplementedAs')
         else:
           self.id = '__getter__'
       elif self.specials == ['setter']:
         self.id = '__setter__'
         # Special case: if it's a setter, ignore 'declared' return type
         self.type = IDLType([('VoidType', None)])
       elif self.specials == ['deleter']:
         self.id = '__delete__'
       else:
         raise Exception('Cannot handle %s: operation has no id' % ast)
@@ skipping 95 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