IDL: Use IdlReader to compute interface_info_individual

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 27 matching lines @@
 module_path = os.path.dirname(__file__)
 source_path = os.path.normpath(os.path.join(module_path, os.pardir, os.pardir,
                                             os.pardir, os.pardir, 'Source'))
 sys.path.append(source_path)  # for Source/bindings imports
 
 import bindings.scripts.compute_interfaces_info_individual
 from bindings.scripts.compute_interfaces_info_individual import compute_info_individual, info_individual
 import bindings.scripts.compute_interfaces_info_overall
 from bindings.scripts.compute_interfaces_info_overall import compute_interfaces_info_overall, interfaces_info
 from bindings.scripts.idl_compiler import IdlCompilerDictionaryImpl, IdlCompilerV8
+from bindings.scripts.idl_reader import IdlReader
 
 
 PASS_MESSAGE = 'All tests PASS!'
 FAIL_MESSAGE = """Some tests FAIL!
 To update the reference files, execute:
     run-bindings-tests --reset-results
 
 If the failures are not due to your changes, test results may be out of sync;
 please rebaseline them in a separate CL, after checking that tests fail in ToT.
 In CL, please set:
 NOTRY=true
 TBR=(someone in Source/bindings/OWNERS or WATCHLISTS:bindings)
 """
 
 DEPENDENCY_IDL_FILES = frozenset([
     'TestImplements.idl',
     'TestImplements2.idl',
     'TestImplements3.idl',
     'TestPartialInterface.idl',
     'TestPartialInterface2.idl',
     'TestPartialInterface3.idl',
 ])
 
+# 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')
 
 PLY_LEX_YACC_FILES = frozenset([
     'lextab.py',  # PLY lex
     'lextab.pyc',
     'parsetab.pickle',  # PLY yacc
 ])
 
 @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
     finally:
         shutil.rmtree(name)
 
 
-def generate_interface_dependencies():
+def generate_interface_dependencies(output_directory):
     def idl_paths_recursive(directory):
         # This is slow, especially on Windows, due to os.walk making
         # excess stat() calls. Faster versions may appear in Python 3.5 or
         # later:
         # https://github.com/benhoyt/scandir
         # http://bugs.python.org/issue11406
         idl_paths = []
         for dirpath, _, files in os.walk(directory):
             idl_paths.extend(os.path.join(dirpath, filename)
                              for filename in fnmatch.filter(files, '*.idl'))
         return idl_paths
 
     # 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.
 
     # 2-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.
+    reader = IdlReader(outputdir=output_directory)
     for idl_filename in idl_paths_recursive(source_path):
-        compute_info_individual(idl_filename)
+        if os.path.basename(idl_filename) in NON_BLINK_IDL_FILES:
+            continue
+        compute_info_individual(idl_filename, reader)
     info_individuals = [info_individual()]
     # 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 info in info_individuals:
         for value in info['interfaces_info'].itervalues():
             value['relative_dir'] = ''
     compute_interfaces_info_overall(info_individuals)
 
@@ skipping 78 matching lines @@
             if relpath not in generated_files:
                 excess_files.append(relpath)
         if excess_files:
             print ('Excess reference files! '
                   '(probably cruft from renaming or deleting):\n' +
                   '\n'.join(excess_files))
             return False
         return True
 
     try:
-        generate_interface_dependencies()
+        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)
 
             idl_compiler = IdlCompilerV8(output_dir,
                                          interfaces_info=interfaces_info,
                                          only_if_changed=True)
             dictionary_impl_compiler = IdlCompilerDictionaryImpl(
                 output_dir, interfaces_info=interfaces_info,
@@ skipping 36 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)