Clean up compute_interfaces_info.py

Source/bindings/scripts/compute_interfaces_info.py

 #!/usr/bin/python
 #
 # Copyright (C) 2013 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
@@ skipping 80 matching lines @@
     'DependentLifetime',
     'WillBeGarbageCollected',
 ])
 
 # Main variable (filled in and exported)
 interfaces_info = {}
 
 # Auxiliary variables (not visible to future build steps)
 partial_interface_files = {}
 parent_interfaces = {}
-extended_attributes_by_interface = {}  # interface name -> extended attributes
+inherited_extended_attributes_by_interface = {}  # interface name -> extended attributes
 
 
 class IdlInterfaceFileNotFoundError(Exception):
     """Raised if the IDL file implementing an interface cannot be found."""
     pass
 
 
 def parse_options():
     usage = 'Usage: %prog [options] [generated1.idl]...'
     parser = optparse.OptionParser(usage=usage)
@@ skipping 55 matching lines @@
     partial_interface_name = get_partial_interface_name_from_idl(idl_file_contents)
     if partial_interface_name:
         add_paths_to_partials_dict(partial_interface_name, full_path, this_include_path)
         return
 
     # If not a partial interface, the basename is the interface name
     interface_name, _ = os.path.splitext(os.path.basename(idl_filename))
 
     interfaces_info[interface_name] = {
         'full_path': full_path,
+        'implemented_as': implemented_as,
         'implements_interfaces': get_implemented_interfaces_from_idl(idl_file_contents, interface_name),
+        'include_path': this_include_path,
         'is_callback_interface': is_callback_interface_from_idl(idl_file_contents),
         # Interfaces that are referenced (used as types) and that we introspect
         # during code generation (beyond interface-level data ([ImplementedAs],
         # is_callback_interface, ancestors, and inherited extended attributes):
         # deep dependencies.
         # These cause rebuilds of referrers, due to the dependency, so these
         # should be minimized; currently only targets of [PutForwards].
         'referenced_interfaces': get_put_forward_interfaces_from_idl(idl_file_contents),
     }
-    if this_include_path:
-        interfaces_info[interface_name]['include_path'] = this_include_path
-    if implemented_as:
-        interfaces_info[interface_name]['implemented_as'] = implemented_as
 
-    # Record auxiliary information
-    extended_attributes_by_interface[interface_name] = extended_attributes
+    # Record inheritance information
+    inherited_extended_attributes_by_interface[interface_name] = dict(
+            (key, value)
+            for key, value in extended_attributes.iteritems()
+            if key in INHERITED_EXTENDED_ATTRIBUTES)
     parent = get_parent_interface(idl_file_contents)
     if parent:
         parent_interfaces[interface_name] = parent
 
 
 def compute_inheritance_info(interface_name):
-    """Computes inheritance information, namely ancestors and inherited extended attributes."""
-    interface_info = interfaces_info[interface_name]
-    interface_extended_attributes = extended_attributes_by_interface[interface_name]
-    inherited_extended_attributes = dict(
-            (key, value)
-            for key, value in interface_extended_attributes.iteritems()
-            if key in INHERITED_EXTENDED_ATTRIBUTES)
-
+    """Compute inheritance information, namely ancestors and inherited extended attributes."""
     def generate_ancestors(interface_name):
         while interface_name in parent_interfaces:
             interface_name = parent_interfaces[interface_name]
             yield interface_name
 
     ancestors = list(generate_ancestors(interface_name))
-    if not ancestors:
-        if inherited_extended_attributes:
-            interface_info['inherited_extended_attributes'] = inherited_extended_attributes
-        return
+    inherited_extended_attributes = inherited_extended_attributes_by_interface[interface_name]
+    for ancestor in ancestors:
+        # Ancestors may not be present, notably if an ancestor is a generated
+        # IDL file and we are running this script from run-bindings-tests,
+        # where we don't generate these files.
+        ancestor_extended_attributes = inherited_extended_attributes_by_interface.get(ancestor, {})
+        inherited_extended_attributes.update(ancestor_extended_attributes)
 
-    interface_info['ancestors'] = ancestors
-    for ancestor in ancestors:
-        # Extended attributes are missing if an ancestor is an interface that
-        # we're not processing, namely real IDL files if only processing test
-        # IDL files.
-        ancestor_extended_attributes = extended_attributes_by_interface.get(ancestor, {})
-        inherited_extended_attributes.update(dict(
-            (key, value)
-            for key, value in ancestor_extended_attributes.iteritems()
-            if key in INHERITED_EXTENDED_ATTRIBUTES))
-    if inherited_extended_attributes:
-        interface_info['inherited_extended_attributes'] = inherited_extended_attributes
+    interfaces_info[interface_name].update({
+        'ancestors': ancestors,
+        'inherited_extended_attributes': inherited_extended_attributes,
+    })
 
 
 def compute_interfaces_info(idl_files):
     """Compute information about IDL files.
 
     Information is stored in global interfaces_info.
     """
     # Compute information for individual files
     for idl_filename in idl_files:
         compute_individual_info(idl_filename)
@@ skipping 11 matching lines @@
                 if interface_name in partial_interface_files else ([], []))
 
         implemented_interfaces = interface_info['implements_interfaces']
         try:
             implemented_interfaces_full_paths = [
                 interfaces_info[interface]['full_path']
                 for interface in implemented_interfaces]
             implemented_interfaces_include_paths = [
                 interfaces_info[interface]['include_path']
                 for interface in implemented_interfaces
-                if 'include_path' in interfaces_info[interface]]
+                if interfaces_info[interface]['include_path']]
         except KeyError as key_name:
             raise IdlInterfaceFileNotFoundError('Could not find the IDL file where the following implemented interface is defined: %s' % key_name)
 
-        interface_info['dependencies_full_paths'] = (
-                partial_interfaces_full_paths +
-                implemented_interfaces_full_paths)
-        interface_info['dependencies_include_paths'] = (
-                partial_interfaces_include_paths +
-                implemented_interfaces_include_paths)
+        interface_info.update({
+            'dependencies_full_paths': (partial_interfaces_full_paths +
+                                        implemented_interfaces_full_paths),
+            'dependencies_include_paths': (partial_interfaces_include_paths +
+                                           implemented_interfaces_include_paths),
+        })
 
 
 ################################################################################
 
 def main():
     options, args = parse_options()
 
     # Static IDL files are passed in a file (generated at GYP time), due to OS
     # command line length limits
     with open(options.idl_files_list) as idl_files_list:
         idl_files = [line.rstrip('\n') for line in idl_files_list]
     # Generated IDL files are passed at the command line, since these are in the
     # build directory, which is determined at build time, not GYP time, so these
     # cannot be included in the file listing static files
     idl_files.extend(args)
 
     compute_interfaces_info(idl_files)
     write_pickle_file(options.interfaces_info_file,
                       interfaces_info,
                       options.write_file_only_if_changed)
 
 
 if __name__ == '__main__':
     sys.exit(main())