Changes to support roll 39 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, IdlUnionType, IdlArrayOrSequenceType
+from idl_types import IdlType, IdlNullableType, IdlUnionType, IdlArrayOrSequenceType
 
 from compute_interfaces_info_overall import interfaces_info
 
 
 new_asts = {}
 
 
 _operation_suffix_map = {
   '__getter__': "Getter",
   '__setter__': "Setter",
@@ skipping 138 matching lines @@
         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" 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':
+          if label == 'Interface' or label == 'Enum' or label == "Dictionary":
             for key in field_value:
               value = field_value[key]
               res.append(value)
           elif isinstance(field_value, list):
             for item in field_value:
               res.append(item)
           elif label == 'ParentInterface' or label == 'InterfaceType':
             # Fetch the AST for the parent interface.
             parent_idlnode = new_asts[field_value]
             res.append(parent_idlnode.interfaces[field_value])
@@ skipping 35 matching lines @@
       'Argument': 'arguments',
       'InterfaceType': 'name',
       'ConstExpr': 'value',
       'Static': 'is_static',
       'ReadOnly': 'is_read_only',
       'Optional': 'is_optional',
       'Nullable': 'is_nullable',
       'Enum': 'enumerations',
       'Annotation': '',         # TODO(terry): Ignore annotation used for database cache.
       'TypeDef': '',            # typedef in an IDL are already resolved.
+      'Dictionary': 'dictionaries',
+      'Member': 'members',
+      'Default': 'default_value',   # Dictionary member default value
     }
     result = label_field.get(label)
     if result != '' and not(result):
       print 'FATAL ERROR: AST mapping name not found %s.' % label
     return result if result else ''
 
   def _convert_all(self, ast, label, idlnode_ctor):
     """Converts AST elements into IDLNode elements.
     Uses _find_all to find elements with a given label and converts
     them into IDLNodes with a given constructor.
@@ skipping 24 matching lines @@
     return idlnode_ctor(childAst)
 
   def _convert_ext_attrs(self, ast):
     """Helper method for uniform conversion of extended attributes."""
     self.ext_attrs = IDLExtAttrs(ast)
 
   def _convert_annotations(self, ast):
     """Helper method for uniform conversion of annotations."""
     self.annotations = IDLAnnotations(ast)
 
+  def _convert_constants(self, ast, js_name):
+    """Helper method for uniform conversion of dictionary members."""
+    self.members = IDLDictionaryMembers(ast, js_name)
+
 
 class IDLDictNode(IDLNode):
   """Base class for dictionary-like IDL nodes such as extended attributes
   and annotations. The base class implements various dict interfaces."""
 
   def __init__(self, ast):
     IDLNode.__init__(self, None)
     if ast is not None and isinstance(ast, dict):
       self.__map = ast
     else:
@@ skipping 57 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)
 
     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)
         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___'];
 
           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:
+        elif interface.id in interfaces_info:
           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:
@@ skipping 65 matching lines @@
           for constructor in ast.constructors:
             if constructor.name == 'NamedConstructor':
               constructor_name = ast.extended_attributes['NamedConstructor']
             else:
               constructor_name = None
             func_value = IDLExtAttrFunctionValue(constructor_name, constructor.arguments, True)
             if name == 'Constructor':
               self.setdefault('Constructor', []).append(func_value)
             else:
               self[name] = func_value
+        elif name == 'SetWrapperReferenceTo':
+          # NOTE: No need to process handling for GC wrapper.  But if its a reference
+          # to another type via an IdlArgument we'd need to convert to IDLArgument
+          # otherwise the type might be a reference to another type and the circularity
+          # will break deep_copy which is done later to the interfaces in the
+          # database.  If we every need SetWrapperReferenceTo then we'd need to
+          # convert IdlArgument to IDLArgument.
+          continue
         else:
           self[name] = value
     else:
       ext_attrs_ast = self._find_first(ast, 'ExtAttrs')
       if not ext_attrs_ast:
         return
       for ext_attr in self._find_all(ext_attrs_ast, 'ExtAttr'):
         name = self._find_first(ext_attr, 'Id')
         value = self._find_first(ext_attr, 'ExtAttrValue')
 
@@ skipping 72 matching lines @@
     elif isinstance(ast, tuple):
       (label, value) = ast
       if label == 'ScopedName':
         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):
+      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)
 
         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'
+          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:
@@ skipping 28 matching lines @@
 
 
 class IDLTypeDef(IDLNode):
   """IDLNode for 'typedef [type] [id]' declarations."""
   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):
+    IDLNode.__init__(self, ast)
+
+    self.javascript_binding_name = self.id
+    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')
+      value = IDLDictionaryMember(member, js_name)
+      self[name] = value
+
+
 class IDLInterface(IDLNode):
   """IDLInterface node contains operations, attributes, constants,
   as well as parent references."""
 
   def __init__(self, ast):
     IDLNode.__init__(self, ast)
     self._convert_ext_attrs(ast)
     self._convert_annotations(ast)
 
     self.parents = self._convert_all(ast, 'ParentInterface',
@@ skipping 152 matching lines @@
     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)
 
 
+class IDLDictionaryMember(IDLMember):
+  """IDLNode specialization for 'const type name = value' declarations."""
+  def __init__(self, ast, doc_js_interface_name):
+    IDLMember.__init__(self, ast, doc_js_interface_name)
+    default_value = self._find_first(ast, 'Default')
+    self.value = default_value.value if default_value else None
+
+
 class IDLImplementsStatement(IDLNode):
   """IDLNode specialization for 'IMPLEMENTOR implements IMPLEMENTED' declarations."""
   def __init__(self, ast):
     IDLNode.__init__(self, ast)
     if isinstance(ast, list) or ast.__module__ != 'idl_definitions':
       self.implementor = self._convert_first(ast, 'ImplStmtImplementor', IDLType)
       self.implemented = self._convert_first(ast, 'ImplStmtImplemented', IDLType)
 
 
 class IDLAnnotations(IDLDictNode):
@@ skipping 13 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