Discard modules information.

lib/html/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 idlparser
 import logging
 import multiprocessing
 import os
 import os.path
 import re
 
 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'
 
-# Used in source annotations to specify the module that the interface was
-# imported from.
-_MODULE_ANNOTATION_ATTR_NAME = 'module'
-
 
 class DatabaseBuilderOptions(object):
   """Used in specifying options when importing new interfaces"""
 
   def __init__(self,
       idl_syntax=idlparser.WEBIDL_SYNTAX,
       idl_defines=[],
       source=None, source_attributes={},
       rename_operation_arguments_on_merge=False,
       add_new_interfaces=True,
@@ skipping 92 matching lines @@
       for type_valued_attribute_name in ['Supplemental']:
         if type_valued_attribute_name in ext_attrs_node:
           value = ext_attrs_node[type_valued_attribute_name]
           if isinstance(value, str):
             ext_attrs_node[type_valued_attribute_name] = strip_modules(value)
 
     map(rename_node, idl_file.all(IDLInterface))
     map(rename_node, idl_file.all(IDLType))
     map(rename_ext_attrs, idl_file.all(IDLExtAttrs))
 
-  def _annotate(self, interface, module_name, import_options):
+  def _annotate(self, interface, import_options):
     """Adds @ annotations based on the source and source_attributes
     members of import_options."""
 
     source = import_options.source
     if not source:
       return
 
     def add_source_annotation(idl_node):
       annotation = IDLAnnotation(
         copy.deepcopy(import_options.source_attributes))
       idl_node.annotations[source] = annotation
       if ((isinstance(idl_node, IDLInterface) or
            isinstance(idl_node, IDLMember)) and
           idl_node.is_fc_suppressed):
         annotation['suppressed'] = None
 
     add_source_annotation(interface)
-    interface.annotations[source][_MODULE_ANNOTATION_ATTR_NAME] = module_name
 
     map(add_source_annotation, interface.parents)
     map(add_source_annotation, interface.constants)
     map(add_source_annotation, interface.attributes)
     map(add_source_annotation, interface.operations)
 
   def _sign(self, node):
     """Computes a unique signature for the node, for merging purposed, by
     concatenating types and names in the declaration."""
     if isinstance(node, IDLType):
@@ skipping 219 matching lines @@
       parent.type = IDLType(implemented_name)
       if source:
         parent.annotations[source] = IDLAnnotation(
             import_options.source_attributes)
       interface.parents.append(parent)
 
   def merge_imported_interfaces(self):
     """Merges all imported interfaces and loads them into the DB."""
 
     # Step 1: Pre process imported interfaces
-    for interface, module_name, import_options in self._imported_interfaces:
-      self._annotate(interface, module_name, import_options)
+    for interface, import_options in self._imported_interfaces:
+      self._annotate(interface, import_options)
 
     # Step 2: Add all new interfaces and merge overlapping ones
-    for interface, module_name, import_options in self._imported_interfaces:
+    for interface, import_options in self._imported_interfaces:
       if not interface.is_supplemental:
         if self._database.HasInterface(interface.id):
           old_interface = self._database.GetInterface(interface.id)
           self._merge_interfaces(old_interface, interface, import_options)
         else:
           if import_options.add_new_interfaces:
             self._database.AddInterface(interface)
 
     # Step 3: Merge in supplemental interfaces
-    for interface, module_name, import_options in self._imported_interfaces:
+    for interface, import_options in self._imported_interfaces:
       if interface.is_supplemental:
         target_name = interface.ext_attrs['Supplemental']
         if target_name:
           # [Supplemental=DOMWindow] - merge into DOMWindow.
           target = target_name
         else:
           # [Supplemental] - merge into existing inteface with same name.
           target = interface.id
         if self._database.HasInterface(target):
           old_interface = self._database.GetInterface(target)
@@ skipping 39 matching lines @@
 
   def _process_idl_file(self, idl_file,
                         import_options):
     self._strip_ext_attributes(idl_file)
     self._resolve_type_defs(idl_file)
     self._rename_types(idl_file, import_options)
 
     def enabled(idl_node):
       return self._is_node_enabled(idl_node, import_options.idl_defines)
 
-    for module in idl_file.modules:
-      for interface in module.interfaces:
-        if not self._is_node_enabled(interface, import_options.idl_defines):
-          _logger.info('skipping interface %s/%s (source=%s)'
-            % (module.id, interface.id, import_options.source))
-          continue
+    for interface in idl_file.interfaces:
+      if not self._is_node_enabled(interface, import_options.idl_defines):
+        _logger.info('skipping interface %s (source=%s)'
+          % (interface.id, import_options.source))
+        continue
 
-        _logger.info('importing interface %s/%s (source=%s)'
-          % (module.id, interface.id, import_options.source))
-        interface.attributes = filter(enabled, interface.attributes)
-        interface.operations = filter(enabled, interface.operations)
-        self._imported_interfaces.append((interface, module.id, import_options))
+      _logger.info('importing interface %s (source=%s)'
+        % (interface.id, import_options.source))
+      interface.attributes = filter(enabled, interface.attributes)
+      interface.operations = filter(enabled, interface.operations)
+      self._imported_interfaces.append((interface, import_options))
 
-      for implStmt in module.implementsStatements:
-        self._impl_stmts.append((implStmt, import_options))
+    for implStmt in idl_file.implementsStatements:
+      self._impl_stmts.append((implStmt, import_options))
+
 
   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 87 matching lines @@
       # 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 DOMWindow 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