[bindings] partial interfaces should not violate componentization

Source/bindings/scripts/interface_dependency_resolver.py

 # 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.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 19 matching lines @@
 
 This library computes interface dependencies (partial interfaces and
 implements), reads the dependency files, and merges them to the IdlDefinitions
 for the main IDL file, producing an IdlDefinitions object representing the
 entire interface.
 
 Design doc: http://www.chromium.org/developers/design-documents/idl-compiler#TOC-Dependency-resolution
 """
 
 import os.path
+from utilities import idl_filename_to_component, is_valid_component_dependency
 
 # The following extended attributes can be applied to a dependency interface,
 # and are then applied to the individual members when merging.
 # Note that this moves the extended attribute from the interface to the member,
 # which changes the semantics and yields different code than the same extended
 # attribute on the main interface.
 DEPENDENCY_EXTENDED_ATTRIBUTES = set([
     'Conditional',
     'PerContextEnabled',
     'RuntimeEnabled',
@@ skipping 53 matching lines @@
                             'have a dictionary.' % definitions.idl_name)
 
         target_interface = next(definitions.interfaces.itervalues())
         interface_name = target_interface.name
         interface_info = self.interfaces_info[interface_name]
 
         if 'inherited_extended_attributes' in interface_info:
             target_interface.extended_attributes.update(
                 interface_info['inherited_extended_attributes'])
 
+        # FIXME: new method for partial interface dependencies full paths?
         resolved_definitions = merge_interface_dependencies(
             definitions,
             component,
             target_interface,
-            interface_info['dependencies_full_paths'],
+            interface_info['dependencies_full_paths'] +
+            interface_info['partial_interface_dependencies_full_paths'],
             self.reader)
 
         for referenced_interface_name in interface_info['referenced_interfaces']:
             referenced_definitions = self.reader.read_idl_definitions(
                 self.interfaces_info[referenced_interface_name]['full_path'])
 
-            if component not in referenced_definitions:
-                raise Exception('This definitions: %s is defined in %s '
-                                'but reference interface:%s is not defined '
-                                'in %s' % (definitions.idl_name,
-                                           component,
-                                           referenced_interface_name,
-                                           component))
+            for referenced_component in referenced_definitions:
+                if not is_valid_component_dependency(component, referenced_component):
+                    raise Exception('This definitions: %s is defined in %s '
+                                    'but reference interface:%s is defined '
+                                    'in %s' % (definitions.idl_name,
+                                               component,
+                                               referenced_interface_name,
+                                               referenced_component))
 
-            resolved_definitions[component].update(referenced_definitions[component])
+                resolved_definitions[component].update(referenced_definitions[component])
+
         return resolved_definitions
 
 
 def merge_interface_dependencies(definitions, component, target_interface, dependency_idl_filenames, reader):
     """Merge dependencies ('partial interface' and 'implements') in dependency_idl_filenames into target_interface.
 
     No return: modifies target_interface in place.

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

Could you update the comment? This method returns a value. Maybe just refer
resolve_dependencies()?

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

Done.

     """
+    resolved_definitions = {component: definitions}
     # Sort so order consistent, so can compare output from run to run.
     for dependency_idl_filename in sorted(dependency_idl_filenames):
         dependency_definitions = reader.read_idl_file(dependency_idl_filename)
-        # FIXME(crbug.com/358074): should not merge core definitions with
-        # modules definitions.
+        dependency_component = idl_filename_to_component(dependency_idl_filename)
+
         dependency_interface = next(dependency_definitions.interfaces.itervalues())
         dependency_interface_basename, _ = os.path.splitext(os.path.basename(dependency_idl_filename))
 
         transfer_extended_attributes(dependency_interface,
                                      dependency_interface_basename)
-        definitions.update(dependency_definitions)  # merges partial interfaces
-        if not dependency_interface.is_partial:
+
+        # We need to use different checkdeps here for partial interface and
+        # inheritance.
+        if dependency_interface.is_partial:
+            # Case: dependency_interface is a partial interface of
+            # target_interface.
+            # So,
+            # - A partial interface defined in modules can update
+            #   the original interface defined in core.
+            # However,
+            # - A partial interface defined in core cannot update
+            #   the original interface defined in modules.
+            if not is_valid_component_dependency(dependency_component, component):
+                raise Exception('The partial interface:%s in %s cannot update '
+                                'the original interface:%s in %s' % (dependency_interface.name,
+                                                                     dependency_component,
+                                                                     target_interface.name,
+                                                                     component))
+
+            if dependency_component in resolved_definitions:
+                resolved_definitions[dependency_component].update(dependency_definitions)

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

Don't we need to update |original_interface| and |partial_interfaces|?

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

In this case, partial interfaces and the original interfaces are defined in the
same component (or allowed components).
So we don't need to generate any special code. We can just merge the interfaces.

[bashi, 2014/10/17 02:23:24]

Acknowledged.

+                continue
+
+            extended_attributes = {}
+            extended_attributes.update(target_interface.extended_attributes)
+            extended_attributes.update(dependency_interface.extended_attributes)
+            dependency_interface.extended_attributes.update(extended_attributes)

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

Can't we do below?

dependency_interface.extended_attributes.update(target_interface.extended_attributes)

This doesn't work if there is a conflict, but in such cases, shouldn't we raise
an exception?

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

Done.

+            assert target_interface == definitions.interfaces[dependency_interface.name]
+            dependency_interface.original_interface = target_interface
+            target_interface.partial_interfaces.append(dependency_interface)
+            resolved_definitions[dependency_component] = dependency_definitions
+        else:
+            # Case: target_interface implements dependency_interface.
+            # So,
+            # - An interface defined in modules can implement some interface
+            #   defined in core.
+            #   In this case, we need "NoInterfaceObject" extended attribute.
+            # However,
+            # - An interface defined in core cannot implement any interface
+            #   defined in modules.
+            if not is_valid_component_dependency(component, dependency_component):
+                raise Exception('The interface:%s in %s cannot implement '
+                                'the interface:%s in %s.' % (dependency_interface.name,
+                                                             dependency_component,
+                                                             target_interface.name,
+                                                             component))
+
+            if component != dependency_component:
+                if 'NoInterfaceObject' not in dependency_interface.extended_attributes:
+                    raise Exception('The interface:%s in %s cannot implement '
+                                    'the interface:%s in %s because of '
+                                    'missing NoInterfaceObject.' % (dependency_interface.name,
+                                                                    dependency_component,
+                                                                    target_interface.name,
+                                                                    component))
+
+            resolved_definitions[component].update(dependency_definitions)  # merges partial interfaces
             # Implemented interfaces (non-partial dependencies) are also merged
             # into the target interface, so Code Generator can just iterate
             # over one list (and not need to handle 'implements' itself).
             target_interface.merge(dependency_interface)
 
-    # FIXME: Currently, this function just returns one IdlDefinitions
-    # instance. However, for partial interface modularization, we need to
-    # make this function return multiple definitions, i.e.
-    # { 'core': ..., 'modules': ... }.
-    return {component: definitions}
+    return resolved_definitions
 
 
 def transfer_extended_attributes(dependency_interface, dependency_interface_basename):
     """Transfer extended attributes from dependency interface onto members.
 
     Merging consists of storing certain interface-level data in extended
     attributes of the *members* (because there is no separate dependency
     interface post-merging).
 
     The data storing consists of:
@@ skipping 37 matching lines @@
         merged_extended_attributes['PartialInterfaceImplementedAs'] = (
             dependency_interface.extended_attributes.get(
                 'ImplementedAs', dependency_interface_basename))
 
     for attribute in dependency_interface.attributes:
         attribute.extended_attributes.update(merged_extended_attributes)
     for constant in dependency_interface.constants:
         constant.extended_attributes.update(merged_extended_attributes)
     for operation in dependency_interface.operations:
         operation.extended_attributes.update(merged_extended_attributes)