[bindings] partial interfaces should not violate componentization

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.utilities import idl_filename_to_component
 
 
 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:
@@ skipping 166 matching lines @@
     try:
         generate_interface_dependencies()
         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)
+            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,
+                    only_if_changed=True,
+                    target_component='modules')
+            else:
+                partial_interface_output_dir = None

[bashi, 2014/10/15 05:29:23]

Remove? It seems that you don't use |partial_interface_output_dir|.

[tasak, 2014/10/15 11:24:19]

Done.

+                idl_partial_interface_compiler = None

[bashi, 2014/10/15 05:29:23]

Question: Does this mean that we don't test partial interfaces in modules?

[tasak, 2014/10/15 11:24:19]

If partial interfaces are defined in modules and the original interfaces are
also defined in modules, the partial interfaces are merged into the original
interfaces.
So we don't see any partial interfaces. We can do this because of no
core/modules violation.

+
             dictionary_impl_compiler = IdlCompilerDictionaryImpl(
                 output_dir, interfaces_info=interfaces_info,
                 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(
                         os.path.realpath(
                             os.path.join(input_directory, filename)))
             for idl_path in idl_filenames:
                 idl_basename = os.path.basename(idl_path)
                 idl_compiler.compile_file(idl_path)
                 definition_name, _ = os.path.splitext(idl_basename)
-                if (definition_name in interfaces_info and interfaces_info[definition_name]['is_dictionary']):
-                    dictionary_impl_compiler.compile_file(idl_path)
+                if definition_name in interfaces_info:
+                    interface_info = interfaces_info[definition_name]
+                    if interface_info['is_dictionary']:
+                        dictionary_impl_compiler.compile_file(idl_path)
+                    if component == 'core' and interface_info['partial_interface_dependencies_full_paths']:
+                        idl_partial_interface_compiler.compile_file(idl_path)
                 if verbose:
                     print 'Compiled: %s' % idl_path
     finally:
         delete_cache_files()
 
     # Detect all changes
     output_files = list_files(output_directory)
     passed = identical_output_files(output_files)
     passed &= no_excess_files(output_files)
 
     if passed:
         if verbose:
             print
             print PASS_MESSAGE
         return 0
     print
     print FAIL_MESSAGE
     return 1
 
 
 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)