Changes to support roll 39 IDLs

tools/dom/scripts/databasebuilder.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 copy
 import database
 import logging
 import monitored
 import multiprocessing
@@ skipping 543 matching lines @@
     return [match.groups() for match in implements_matches]
 
   # Compile the IDL file with the Blink compiler and remember each AST for the
   # IDL.
   def _blink_compile_idl_files(self, file_paths, import_options, is_dart_idl):
     if not(is_dart_idl):
       start_time = time.time()
 
       # 2-stage computation: individual, then overall
       for file_path in file_paths:
-        compute_info_individual(file_path, 'dart')
+        compute_info_individual(file_path)
       info_individuals = [info_individual()]
       compute_interfaces_info_overall(info_individuals)
 
       end_time = time.time()
       print 'Compute dependencies %s seconds' % round((end_time - start_time), 2)
     else:
       # Compute the interface_info for dart.idl for implements defined.  This
       # file is special in that more than one interface can exist in this file.
       implement_pairs = self._compute_dart_idl_implements(file_paths[0])
 
       interfaces_info['__dart_idl___'] = {
         'implement_pairs': implement_pairs,
       }
 
     # Parse the IDL files serially.
     start_time = time.time()
 
     for file_path in file_paths:
       file_path = os.path.normpath(file_path)
       ast = _compile_idl_file(self.build, file_path, import_options)
       self._process_ast(os.path.splitext(os.path.basename(file_path))[0], ast)
 
     end_time = time.time()
     print 'Compiled %s IDL files in %s seconds' % (len(file_paths),
                                                   round((end_time - start_time), 2))
 
   def _process_ast(self, filename, ast):
+    if len(ast) == 1:
+      ast = ast.values()[0]
+    else:
+      print 'ERROR: Processing AST: ' + os.path.basename(file_name)
     new_asts[filename] = ast
 
   def import_idl_files(self, file_paths, import_options, is_dart_idl):
     self._blink_compile_idl_files(file_paths, import_options, is_dart_idl)
 
     start_time = time.time()
 
     # Parse the IDL files in serial.
     for file_path in file_paths:
       file_path = os.path.normpath(file_path)
@@ skipping 21 matching lines @@
           % (interface.id, import_options.source))
         continue
 
       _logger.info('importing interface %s (source=%s file=%s)'
         % (interface.id, import_options.source, os.path.basename(idl_file.filename)))
 
       interface.attributes = filter(enabled, interface.attributes)
       interface.operations = filter(enabled, interface.operations)
       self._imported_interfaces.append((interface, import_options))
 
-    for implStmt in idl_file.implementsStatements:
-      self._impl_stmts.append((implStmt, import_options))
+    # If an IDL dictionary then there is no implementsStatements.
+    if hasattr(idl_file, 'implementsStatements'):
+      for implStmt in idl_file.implementsStatements:
+        self._impl_stmts.append((implStmt, import_options))
 
     for enum in idl_file.enums:
       self._database.AddEnum(enum)
 
+    for dictionary in idl_file.dictionaries:
+      self._database.AddDictionary(dictionary)
+
 
   def _is_node_enabled(self, node, idl_defines):
     if not 'Conditional' in node.ext_attrs:
       return True
 
     def enabled(condition):
       return 'ENABLE_%s' % condition in idl_defines
 
     conditional = node.ext_attrs['Conditional']
     if conditional.find('&') != -1:
@@ skipping 74 matching lines @@
             for name, value in annotation.items():
               if (name in top_level_annotation
                   and value == top_level_annotation[name]):
                 del annotation[name]
 
         map(normalize, interface.parents)
         map(normalize, interface.constants)
         map(normalize, interface.attributes)
         map(normalize, interface.operations)
 
+  def map_dictionaries(self):
+    """Changes the type of operations/constructors arguments from an IDL
+       dictionary to a Dictionary.  The IDL dictionary is just an enums of
+       strings which are checked at run-time."""
+    def dictionary_to_map(type_node):
+      if self._database.HasDictionary(type_node.id):
+        type_node.dictionary = type_node.id
+        type_node.id = 'Dictionary'
+
+    def all_types(node):
+      map(dictionary_to_map, node.all(IDLType))
+
+    for interface in self._database.GetInterfaces():
+      map(all_types, interface.all(IDLExtAttrFunctionValue))
+      map(all_types, interface.operations)
+
   def fetch_constructor_data(self, options):
     window_interface = self._database.GetInterface('Window')
     for attr in window_interface.attributes:
       type = attr.type.id
       if not type.endswith('Constructor'):
         continue
       type = re.sub('(Constructor)+$', '', type)
       # TODO(antonm): Ideally we'd like to have pristine copy of WebKit IDLs and fetch
       # this information directly from it.  Unfortunately right now database is massaged
       # a lot so it's difficult to maintain necessary information on Window itself.
       interface = self._database.GetInterface(type)
       if 'V8EnabledPerContext' in attr.ext_attrs:
         interface.ext_attrs['synthesizedV8EnabledPerContext'] = \
             attr.ext_attrs['V8EnabledPerContext']
       if 'V8EnabledAtRuntime' in attr.ext_attrs:
         interface.ext_attrs['synthesizedV8EnabledAtRuntime'] = \
             attr.ext_attrs['V8EnabledAtRuntime'] or attr.id