Dartium 45 roll

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
 import os
 import os.path
 import re
 import sys
 import tempfile
 import time
 import traceback
 
 import idl_validator
 
 import compiler
 import compute_interfaces_info_individual
-from compute_interfaces_info_individual import compute_info_individual, info_individual
-import compute_interfaces_info_overall
-from compute_interfaces_info_overall import compute_interfaces_info_overall, interfaces_info
+from compute_interfaces_info_individual import InterfaceInfoCollector
 import idl_definitions
 
 from idlnode import *
 
 _logger = logging.getLogger('databasebuilder')
 
 # Used in source annotations to specify the parent interface declaring
 # a displaced declaration. The 'via' attribute specifies the parent interface
 # which implements a displaced declaration.
 _VIA_ANNOTATION_ATTR_NAME = 'via'
@@ skipping 89 matching lines @@
         #              driven by the databasebuilder.  Blink compiler requires
         #              an output directory even though we don't use (yet). Might
         #              use the code generator portion of the new IDL compiler
         #              then we'd have a real output directory. Today we use the
         #              compiler to only create an AST.
         self.output_directory = tempfile.mkdtemp()
         attrib_file = os.path.join('Source', idl_validator.EXTENDED_ATTRIBUTES_FILENAME)
         # Create compiler.
         self.idl_compiler = compiler.IdlCompilerDart(self.output_directory,
                                             attrib_file,
-                                            interfaces_info=interfaces_info,
+                                            interfaces_info=provider._info_collector.interfaces_info,
                                             only_if_changed=True)
 
     def format_exception(self, e):
         exception_list = traceback.format_stack()
         exception_list = exception_list[:-2]
         exception_list.extend(traceback.format_tb(sys.exc_info()[2]))
         exception_list.extend(traceback.format_exception_only(sys.exc_info()[0], sys.exc_info()[1]))
 
         exception_str = "Traceback (most recent call last):\n"
         exception_str += "".join(exception_list)
@@ skipping 15 matching lines @@
 
             return 1
 
         return IDLFile(idl_ast, file_name)
 
 
 class DatabaseBuilder(object):
   def __init__(self, database):
     """DatabaseBuilder is used for importing and merging interfaces into
     the Database"""
+    self._info_collector = InterfaceInfoCollector()
+
     self._database = database
     self._imported_interfaces = []
     self._impl_stmts = []
     self.conditionals_met = set()
 
     # Spin up the new IDL parser.
-    self.build = Build(None)
+    self.build = Build(self)
 
     # Global typedef to mapping.
     self.global_type_defs = monitored.Dict('databasebuilder.global_type_defs', {
       'Transferable' : 'MessagePort',
     })
 
   # TODO(terry): Consider keeping richer type information (e.g.,
   #              IdlArrayOrSequenceType from the Blink parser) instead of just
   #              a type name.
   def _resolve_type_defs(self, idl_file):
     for type_node in idl_file.all(IDLType):
+      resolved = False
       type_name = type_node.id
       for typedef in self.global_type_defs:
         seq_name_typedef = 'sequence<%s>' % typedef
         if type_name == typedef:
           type_node.id = self.global_type_defs[typedef]
+          resolved = True
         elif type_name == seq_name_typedef:
           type_node.id = 'sequence<%s>' % self.global_type_defs[typedef]
+          resolved = True
+      if not(resolved):
+        for typedef in idl_file.typeDefs:
+          if type_name == typedef.id:
+            type_node.id = typedef.type.id
+            resolved = True
 
   def _strip_ext_attributes(self, idl_file):
     """Strips unuseful extended attributes."""
     for ext_attrs in idl_file.all(IDLExtAttrs):
       # TODO: Decide which attributes are uninteresting.
       pass
 
   def _rename_types(self, idl_file, import_options):
     """Rename interface and type names with names provided in the
     options. Also clears scopes from scoped names"""
@@ skipping 346 matching lines @@
 
     implements_matches = re.finditer(implements_re, idl_file_contents, re.MULTILINE)
     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
+    # Compute information for individual files
+    # Information is stored in global variables interfaces_info and
+    # partial_interface_files.
       for file_path in file_paths:
-        compute_info_individual(file_path)
-      info_individuals = [info_individual()]
-      compute_interfaces_info_overall(info_individuals)
+        self._info_collector.collect_info(file_path)
 
       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___'] = {
+      self._info_collector.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)
@@ skipping 52 matching lines @@
     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)
 
+    # TODO(terry): Hack to remember all typedef unions they're mapped to any
+    #              - no type.
+    for typedef in idl_file.typeDefs:
+      self._database.AddTypeDef(typedef)
 
   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 349 matching lines @@
            | columns[0] | columns[1] | columns[2] | ... |
     """
     if len(columns) > 0:
       for column in columns:
         value = '' if not column else column
         sys.stdout.write('|{0:^{1}}'.format(value, self._TABULATE_WIDTH()))
     else:
       sys.stdout.write('|{0:^{1}}'.format('', self._TABULATE_WIDTH()))
 
     sys.stdout.write('|\n')