Generate separate files for union type containers

third_party/WebKit/Source/bindings/scripts/code_generator_v8.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 111 matching lines @@
     IdlType.set_enums(info_provider.enumerations)
     IdlType.set_implemented_as_interfaces(interfaces_info['implemented_as_interfaces'])
     IdlType.set_garbage_collected_types(interfaces_info['garbage_collected_interfaces'])
     v8_types.set_component_dirs(interfaces_info['component_dirs'])
 
 
 def should_generate_code(definitions):
     return definitions.interfaces or definitions.dictionaries
 
 
-def depends_on_union_types(idl_type):
-    """Returns true when a given idl_type depends on union containers
-    directly.
+def depending_union_type_name(idl_type):
+    """Returns the union type name if the given idl_type depends on a
+    union type.
     """
-    if idl_type.is_union_type:
-        return True
-    if idl_type.is_array_or_sequence_type:
-        return idl_type.element_type.is_union_type
-    return False
+    def find_base_type(current_type):
+        if current_type.is_array_or_sequence_type:
+            return find_base_type(current_type.element_type)
+        if current_type.is_nullable:
+            return find_base_type(current_type.inner_type)
+        return current_type
+    base_type = find_base_type(idl_type)
+    if base_type.is_union_type:
+        return base_type.name
+    return None
 
 
 class TypedefResolver(Visitor):
     def __init__(self, info_provider):
         self.info_provider = info_provider
 
     def resolve(self, definitions, definition_name):
         """Traverse definitions and resolves typedefs with the actual types."""
         self.typedefs = {}
         for name, typedef in self.info_provider.typedefs.iteritems():
             self.typedefs[name] = typedef.idl_type
-        self.additional_includes = set()
+        self.additional_header_includes = set()
         definitions.accept(self)
         self._update_dependencies_include_paths(definition_name)
 
     def _update_dependencies_include_paths(self, definition_name):
         interface_info = self.info_provider.interfaces_info[definition_name]
-        dependencies_include_paths = interface_info['dependencies_include_paths']
-        for include_path in self.additional_includes:
-            if include_path not in dependencies_include_paths:
-                dependencies_include_paths.append(include_path)
+        interface_info['additional_header_includes'] = set(
+            self.additional_header_includes)
 
     def _resolve_typedefs(self, typed_object):
         """Resolve typedefs to actual types in the object."""
         for attribute_name in typed_object.idl_type_attributes:
             try:
                 idl_type = getattr(typed_object, attribute_name)
             except AttributeError:
                 continue
             if not idl_type:
                 continue
             resolved_idl_type = idl_type.resolve_typedefs(self.typedefs)
-            if depends_on_union_types(resolved_idl_type):
-                self.additional_includes.add(
-                    self.info_provider.include_path_for_union_types)
+            # TODO(bashi): Dependency resolution shouldn't happen here.
+            # Move this into includes_for_type() families.
+            union_type_name = depending_union_type_name(resolved_idl_type)
+            if union_type_name:
+                self.additional_header_includes.add(
+                    self.info_provider.include_path_for_union_types(
+                        union_type_name))
             # Need to re-assign the attribute, not just mutate idl_type, since
             # type(idl_type) may change.
             setattr(typed_object, attribute_name, resolved_idl_type)
 
     def visit_typed_object(self, typed_object):
         self._resolve_typedefs(typed_object)
 
 
 class CodeGeneratorBase(object):
     """Base class for v8 bindings generator and IDL dictionary impl generator"""
@@ skipping 72 matching lines @@
         template_context = interface_context(interface)
         includes.update(interface_info.get('cpp_includes', {}).get(component, set()))
         if not interface.is_partial and not is_testing_target(full_path):
             template_context['header_includes'].add(self.info_provider.include_path_for_export)
             template_context['exported'] = self.info_provider.specifier_for_export
         # Add the include for interface itself
         if IdlType(interface_name).is_typed_array:
             template_context['header_includes'].add('core/dom/DOMTypedArray.h')
         elif interface_info['include_path']:
             template_context['header_includes'].add(interface_info['include_path'])
-
+        template_context['header_includes'].update(
+            interface_info.get('additional_header_includes', []))
         header_template = self.jinja_env.get_template(header_template_filename)
         cpp_template = self.jinja_env.get_template(cpp_template_filename)
         header_text, cpp_text = render_template(
             include_paths, header_template, cpp_template, template_context,
             component)
         header_path, cpp_path = self.output_paths(interface_name)
         return (
             (header_path, header_text),
             (cpp_path, cpp_text),
         )
@@ skipping 37 matching lines @@
         if not definition_name in definitions.dictionaries:
             raise ValueError('%s is not an IDL dictionary')
         interfaces_info = self.info_provider.interfaces_info
         dictionary = definitions.dictionaries[definition_name]
         interface_info = interfaces_info[definition_name]
         header_template = self.jinja_env.get_template('dictionary_impl.h')
         cpp_template = self.jinja_env.get_template('dictionary_impl.cpp')
         template_context = v8_dictionary.dictionary_impl_context(
             dictionary, interfaces_info)
         include_paths = interface_info.get('dependencies_include_paths')
-        # Add union containers header file to header_includes rather than
-        # cpp file so that union containers can be used in dictionary headers.
-        union_container_headers = [header for header in include_paths
-                                   if header.find('UnionTypes') > 0]
-        include_paths = [header for header in include_paths
-                         if header not in union_container_headers]
-        template_context['header_includes'].update(union_container_headers)
         if not is_testing_target(interface_info.get('full_path')):
             template_context['exported'] = self.info_provider.specifier_for_export
             template_context['header_includes'].add(self.info_provider.include_path_for_export)
+        template_context['header_includes'].update(
+            interface_info.get('additional_header_includes', []))
         header_text, cpp_text = render_template(
             include_paths, header_template, cpp_template, template_context)
         header_path, cpp_path = self.output_paths(
             cpp_name(dictionary), interface_info)
         return (
             (header_path, header_text),
             (cpp_path, cpp_text),
         )
 
 
 class CodeGeneratorUnionType(object):
     """Generates union type container classes.
     This generator is different from CodeGeneratorV8 and
     CodeGeneratorDictionaryImpl. It assumes that all union types are already
     collected. It doesn't process idl files directly.
     """
     def __init__(self, info_provider, cache_dir, output_dir, target_component):
         self.info_provider = info_provider
         self.jinja_env = initialize_jinja_env(cache_dir)
         self.output_dir = output_dir
         self.target_component = target_component
         set_global_type_info(info_provider)
 
-    def generate_code(self):
-        union_types = self.info_provider.union_types
-        if not union_types:
-            return ()
-        header_template = self.jinja_env.get_template('union.h')
-        cpp_template = self.jinja_env.get_template('union.cpp')
-        template_context = v8_union.union_context(
-            union_types, self.info_provider.interfaces_info)
+    def _generate_container_code(self, union_type):
+        header_template = self.jinja_env.get_template('union_container.h')
+        cpp_template = self.jinja_env.get_template('union_container.cpp')
+        template_context = v8_union.container_context(
+            union_type, self.info_provider.interfaces_info)
+        template_context['header_includes'].append(
+            self.info_provider.include_path_for_export)
+        template_context['header_includes'] = normalize_and_sort_includes(
+            template_context['header_includes'])
         template_context['code_generator'] = module_pyname
-        capitalized_component = self.target_component.capitalize()
         template_context['exported'] = self.info_provider.specifier_for_export
-        template_context['header_filename'] = 'bindings/%s/v8/UnionTypes%s.h' % (
-            self.target_component, capitalized_component)
-        template_context['macro_guard'] = 'UnionType%s_h' % capitalized_component
-        additional_header_includes = [self.info_provider.include_path_for_export]
-
-        # Add UnionTypesCore.h as a dependency when we generate modules union types
-        # because we only generate union type containers which are used by both
-        # core and modules in UnionTypesCore.h.
-        # FIXME: This is an ad hoc workaround and we need a general way to
-        # handle core <-> modules dependency.
-        if self.target_component == 'modules':
-            additional_header_includes.append(
-                'bindings/core/v8/UnionTypesCore.h')
-
-        template_context['header_includes'] = normalize_and_sort_includes(
-            template_context['header_includes'] + additional_header_includes)
-
         header_text = header_template.render(template_context)
         cpp_text = cpp_template.render(template_context)
-        header_path = posixpath.join(self.output_dir,
-                                     'UnionTypes%s.h' % capitalized_component)
-        cpp_path = posixpath.join(self.output_dir,
-                                  'UnionTypes%s.cpp' % capitalized_component)
+        name = union_type.cpp_type
+        header_path = posixpath.join(self.output_dir, '%s.h' % name)
+        cpp_path = posixpath.join(self.output_dir, '%s.cpp' % name)
         return (
             (header_path, header_text),
             (cpp_path, cpp_text),
         )
 
+    def _get_union_types_for_containers(self):
+        union_types = self.info_provider.union_types
+        if not union_types:
+            return None
+        # For container classes we strip nullable wrappers. For example,
+        # both (A or B)? and (A? or B) will become AOrB. This should be OK
+        # because container classes can handle null and it seems that
+        # distinguishing (A or B)? and (A? or B) doesn't make sense.
+        container_cpp_types = set()
+        union_types_for_containers = set()
+        for union_type in union_types:
+            cpp_type = union_type.cpp_type
+            if cpp_type not in container_cpp_types:
+                union_types_for_containers.add(union_type)
+                container_cpp_types.add(cpp_type)
+        return union_types_for_containers
+
+    def generate_code(self):
+        union_types = self._get_union_types_for_containers()
+        if not union_types:
+            return ()
+        outputs = set()
+        for union_type in union_types:
+            outputs.update(self._generate_container_code(union_type))
+        return outputs
+
 
 def initialize_jinja_env(cache_dir):
     jinja_env = jinja2.Environment(
         loader=jinja2.FileSystemLoader(templates_dir),
         # Bytecode cache is not concurrency-safe unless pre-cached:
         # if pre-cached this is read-only, but writing creates a race condition.
         bytecode_cache=jinja2.FileSystemBytecodeCache(cache_dir),
         keep_trailing_newline=True,  # newline-terminate generated files
         lstrip_blocks=True,  # so can indent control flow tags
         trim_blocks=True)
@@ skipping 48 matching lines @@
 
     # Create a dummy file as output for the build system,
     # since filenames of individual cache files are unpredictable and opaque
     # (they are hashes of the template path, which varies based on environment)
     with open(dummy_filename, 'w') as dummy_file:
         pass  # |open| creates or touches the file
 
 
 if __name__ == '__main__':
     sys.exit(main(sys.argv))