IDL: Defer typedef resolution

Tools/Scripts/webkitpy/bindings/main.py

 # Copyright (C) 2011 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:
 # 1. Redistributions of source code must retain the above copyright
 #    notice, this list of conditions and the following disclaimer.
 # 2. Redistributions in binary form must reproduce the above copyright
 #    notice, this list of conditions and the following disclaimer in the
 #    documentation and/or other materials provided with the distribution.
@@ skipping 63 matching lines @@
 # core/inspector/InspectorInstrumentation.idl is not a valid Blink IDL.
 NON_BLINK_IDL_FILES = frozenset([
     'InspectorInstrumentation.idl',
 ])
 
 COMPONENT_DIRECTORY = frozenset(['core', 'modules'])
 
 test_input_directory = os.path.join(source_path, 'bindings', 'tests', 'idls')
 reference_directory = os.path.join(source_path, 'bindings', 'tests', 'results')
 
-# component -> set of union types
-union_types = {}
+# component -> component_info.
+# Note that this dict contains information about testing idl files, which live
+# in Source/bindings/tests/idls/{core,modules}, not in Source/{core,modules}.
+test_component_info = {}
 
 @contextmanager
 def TemporaryDirectory():
     """Wrapper for tempfile.mkdtemp() so it's usable with 'with' statement.
 
     Simple backport of tempfile.TemporaryDirectory from Python 3.2.
     """
     name = tempfile.mkdtemp()
     try:
         yield name
@@ skipping 30 matching lines @@
             info_collector.collect_info(idl_path)
         info = info_collector.get_info_as_dict()
         # TestDictionary.{h,cpp} are placed under
         # Source/bindings/tests/idls/core. However, IdlCompiler generates
         # TestDictionary.{h,cpp} by using relative_dir.
         # So the files will be generated under
         # output_dir/core/bindings/tests/idls/core.
         # To avoid this issue, we need to clear relative_dir here.
         for value in info['interfaces_info'].itervalues():
             value['relative_dir'] = ''
-        # Merge component-wide information.
         component_info = info_collector.get_component_info_as_dict()
-        info.update(component_info)
-        return info
+        return info, component_info
 
     # We compute interfaces info for *all* IDL files, not just test IDL
     # files, as code generator output depends on inheritance (both ancestor
     # chain and inherited extended attributes), and some real interfaces
     # are special-cased, such as Node.
     #
     # For example, when testing the behavior of interfaces that inherit
     # from Node, we also need to know that these inherit from EventTarget,
     # since this is also special-cased and Node inherits from EventTarget,
     # but this inheritance information requires computing dependencies for
     # the real Node.idl file.
     non_test_idl_paths = collect_blink_idl_paths()
     # For bindings test IDL files, we collect interfaces info for each
     # component so that we can generate union type containers separately.
     test_idl_paths = {}
     for component in COMPONENT_DIRECTORY:
         test_idl_paths[component] = idl_paths_recursive(
             os.path.join(test_input_directory, component))
     # 2nd-stage computation: individual, then overall
     #
     # Properly should compute separately by component (currently test
     # includes are invalid), but that's brittle (would need to update this file
     # for each new component) and doesn't test the code generator any better
     # than using a single component.
-    non_test_interfaces_info = collect_interfaces_info(non_test_idl_paths)
+    non_test_interfaces_info, non_test_component_info = collect_interfaces_info(non_test_idl_paths)
     test_interfaces_info = {}
     for component, paths in test_idl_paths.iteritems():
-        test_interfaces_info[component] = collect_interfaces_info(paths)
+        test_interfaces_info[component], test_component_info[component] = collect_interfaces_info(paths)
     # In order to allow test IDL files to override the production IDL files if
     # they have the same interface name, process the test IDL files after the
     # non-test IDL files.
     info_individuals = [non_test_interfaces_info] + test_interfaces_info.values()
     compute_interfaces_info_overall(info_individuals)
-    # 3rd-stage: union types
-    # We only process union types which are defined under
-    # Source/bindings/tests/idls. Otherwise, the result of union type
-    # container classes will be affected by non-test IDL files.
-    for component, interfaces_info in test_interfaces_info.iteritems():
-        union_types[component] = interfaces_info['union_types']
 
 
 def bindings_tests(output_directory, verbose):
     executive = Executive()
 
     def list_files(directory):
         files = []
         for component in os.listdir(directory):
             if component not in COMPONENT_DIRECTORY:
                 continue
@@ skipping 68 matching lines @@
             print ('Excess reference files! '
                   '(probably cruft from renaming or deleting):\n' +
                   '\n'.join(excess_files))
             return False
         return True
 
     def generate_union_type_containers(output_directory, component):
         generator = CodeGeneratorUnionType(
             interfaces_info, cache_dir=None, output_dir=output_directory,
             target_component=component)
-        outputs = generator.generate_code(union_types[component])
+        outputs = generator.generate_code(
+            test_component_info[component]['union_types'])
         for output_path, output_code in outputs:
             write_file(output_code, output_path, only_if_changed=True)
 
     try:
         generate_interface_dependencies(output_directory)
         for component in COMPONENT_DIRECTORY:
             output_dir = os.path.join(output_directory, component)
             if not os.path.exists(output_dir):
                 os.makedirs(output_dir)
 
             generate_union_type_containers(output_dir, component)
 
             idl_compiler = IdlCompilerV8(output_dir,
                                          interfaces_info=interfaces_info,
+                                         component_info=test_component_info[component],
                                          only_if_changed=True)
             if component == 'core':
                 partial_interface_output_dir = os.path.join(output_directory,
                                                             'modules')
                 if not os.path.exists(partial_interface_output_dir):
                     os.makedirs(partial_interface_output_dir)
                 idl_partial_interface_compiler = IdlCompilerV8(
                     partial_interface_output_dir,
                     interfaces_info=interfaces_info,
+                    component_info=test_component_info[component],
                     only_if_changed=True,
                     target_component='modules')
             else:
                 idl_partial_interface_compiler = None
 
             dictionary_impl_compiler = IdlCompilerDictionaryImpl(
                 output_dir, interfaces_info=interfaces_info,
+                component_info=test_component_info[component],
                 only_if_changed=True)
 
             idl_filenames = []
             input_directory = os.path.join(test_input_directory, component)
             for filename in os.listdir(input_directory):
                 if (filename.endswith('.idl') and
                     # Dependencies aren't built
                     # (they are used by the dependent)
                     filename not in DEPENDENCY_IDL_FILES):
                     idl_filenames.append(
@@ skipping 30 matching lines @@
 
 
 def run_bindings_tests(reset_results, verbose):
     # Generate output into the reference directory if resetting results, or
     # a temp directory if not.
     if reset_results:
         print 'Resetting results'
         return bindings_tests(reference_directory, verbose)
     with TemporaryDirectory() as temp_dir:
         return bindings_tests(temp_dir, verbose)