Refactor code generation to allow us to diff generic expressions and not just fields

third_party/WebKit/Source/build/scripts/make_computed_style_base.py

 #!/usr/bin/env python
 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import math
 import sys
 
 import json5_generator
 import template_expander
@@ skipping 56 matching lines @@
         self.type_name = class_name(join_name('style', name, 'data'))
         self.member_name = class_member_name(join_name(name, 'data'))
         self.num_32_bit_words_for_bit_fields = _num_32_bit_words_for_bit_fields(
             field for field in fields if field.is_bit_field
         )
 
         # Recursively get all the fields in the subgroups as well
         self.all_fields = _flatten_list(subgroup.all_fields for subgroup in subgroups) + fields
 
 
+class DiffGroup(object):
+    """Represents a group of expressions and subgroups that need to be diffed
+    for a function in ComputedStyle.
+
+    Attributes:
+        subgroups: List of DiffGroup instances that are stored as subgroups under this group.
+        expressions: List of expression that are on this group that need to be diffed.
+    """
+    def __init__(self, group_name):
+        self.group_name = group_name
+        self.subgroups = []
+        self.expressions = []
+
 class Field(object):
     """
     The generated ComputedStyle object is made up of a series of Fields.
     Each Field has a name, size, type, etc, and a bunch of attributes to
     determine which methods it will be used in.
 
     A Field also has enough information to use any storage type in C++, such as
     regular member variables, or more complex storage like vectors or hashmaps.
     Almost all properties will have at least one Field, often more than one.
 
@@ skipping 45 matching lines @@
 
         # Method names
         # TODO(nainar): Method name generation is inconsistent. Fix.
         self.getter_method_name = getter_method_name
         self.setter_method_name = setter_method_name
         self.internal_getter_method_name = method_name(join_name(getter_method_name, 'Internal'))
         self.internal_mutable_method_name = method_name(join_name('Mutable', name_for_methods, 'Internal'))
         self.internal_setter_method_name = method_name(join_name(setter_method_name, 'Internal'))
         self.initial_method_name = initial_method_name
         self.resetter_method_name = method_name(join_name('Reset', name_for_methods))
+        if self.group_name:
+            self.getter_expression = self.group_name + '_data_->' + class_member_name(self.name)

[shend, 2017/05/11 06:11:27]

I think you can use 'self.group_member_name' instead of self.group_name +
'_data'.

[nainar, 2017/05/11 06:32:38]

Done.

+        else:
+            self.getter_expression = class_member_name(self.name)
 
         # If the size of the field is not None, it means it is a bit field
         self.is_bit_field = self.size is not None
 
         assert len(kwargs) == 0, 'Unexpected arguments provided to Field: ' + str(kwargs)
 
 
 def _get_include_paths(properties):
     """
     Get a list of paths that need to be included for ComputedStyleBase.
     """
     include_paths = set()
     for property_ in properties:
         if property_['field_type_path'] is not None:
             include_paths.add(property_['field_type_path'] + '.h')
     return list(sorted(include_paths))
 
 
 def _group_fields(fields):
     """Groups a list of fields by their group_name and returns the root group."""
     groups = defaultdict(list)
     for field in fields:
         groups[field.group_name].append(field)
 
-    no_group = groups.pop(None)
+    no_group = {}

[shend, 2017/05/11 06:11:27]

No longer needed I believe.

[nainar, 2017/05/11 06:32:38]

Done.

+    if groups.get(None):
+        no_group = groups.pop(None)
     subgroups = [Group(group_name, [], _reorder_fields(fields)) for group_name, fields in groups.items()]
     return Group('', subgroups=subgroups, fields=_reorder_fields(no_group))
 
 
+def _create_diff_groups_map(diff_function_inputs, root_group):
+    diff_functions_map = {}
+    for entry in diff_function_inputs:
+        diff_functions_map[entry['name']] = _create_diff_groups(entry['fields'], root_group)
+    return diff_functions_map
+
+
+def _create_diff_groups(fields_to_diff, root_group):
+    diff_group = DiffGroup(root_group.member_name)
+    for subgroup in root_group.subgroups:
+        for field in subgroup.all_fields:

[shend, 2017/05/11 06:11:27]

This is the intersection code right? I think you can just do a one-liner:

if any(field.property_name in subgroup.all_fields for field in fields_to_diff):
   append

or

if len(set(subgroup.all_fields) & set(fields_to_diff)) > 0:

[nainar, 2017/05/11 06:32:38]

Done. With protest

+            if field.property_name in fields_to_diff:
+                diff_group.subgroups.append(_create_diff_groups(fields_to_diff, subgroup))
+                break
+    for field in root_group.fields:
+        if field.property_name in fields_to_diff:
+            diff_group.expressions.append(field.getter_expression)
+    return diff_group
+
+
 def _create_enums(properties):
     """
     Returns an OrderedDict of enums to be generated, enum name -> [list of enum values]
     """
     enums = {}
     for property_ in properties:
         # Only generate enums for keyword properties that use the default field_type_path.
         if property_['field_template'] == 'keyword' and property_['field_type_path'] is None:
             enum_name = property_['type_name']
             enum_values = [enum_value_name(k) for k in property_['keywords']]
@@ skipping 185 matching lines @@
             if property_['field_type_path']:
                 property_['type_name'] = property_['field_type_path'].split('/')[-1]
 
         self._generated_enums = _create_enums(all_properties)
 
         all_fields = _create_fields(all_properties)
 
         # Organise fields into a tree structure where the root group
         # is ComputedStyleBase.
         self._root_group = _group_fields(all_fields)
+        self._diff_functions_map = _create_diff_groups_map(json5_generator.Json5File.load_from_files(
+            [json5_file_paths[2]]
+        ).name_dictionaries, self._root_group)
 
         self._include_paths = _get_include_paths(all_properties)
         self._outputs = {
             'ComputedStyleBase.h': self.generate_base_computed_style_h,
             'ComputedStyleBase.cpp': self.generate_base_computed_style_cpp,
             'ComputedStyleBaseConstants.h': self.generate_base_computed_style_constants,
         }
 
     @template_expander.use_jinja('ComputedStyleBase.h.tmpl', tests={'in': lambda a, b: a in b})
     def generate_base_computed_style_h(self):
         return {
             'properties': self._properties,
             'enums': self._generated_enums,
             'include_paths': self._include_paths,
             'computed_style': self._root_group,
         }
 
     @template_expander.use_jinja('ComputedStyleBase.cpp.tmpl', tests={'in': lambda a, b: a in b})
     def generate_base_computed_style_cpp(self):
         return {
             'properties': self._properties,
             'enums': self._generated_enums,
             'computed_style': self._root_group,
+            'diff_functions_map': self._diff_functions_map,
         }
 
     @template_expander.use_jinja('ComputedStyleBaseConstants.h.tmpl')
     def generate_base_computed_style_constants(self):
         return {
             'properties': self._properties,
             'enums': self._generated_enums,
         }
 
 if __name__ == '__main__':
     json5_generator.Maker(ComputedStyleBaseWriter).main()