supersize: Fix diff logic for changed vs unchanged of groups

tools/binary_size/libsupersize/models.py

 # Copyright 2017 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.
 """Classes that comprise the data model for binary size analysis.
 
 The primary classes are Symbol, and SymbolGroup.
 
 Description of common properties:
   * address: The start address of the symbol.
         May be 0 (e.g. for .bss or for SymbolGroups).
@@ skipping 41 matching lines @@
     't': '.text',
 }
 
 FLAG_ANONYMOUS = 1
 FLAG_STARTUP = 2
 FLAG_UNLIKELY = 4
 FLAG_REL = 8
 FLAG_REL_LOCAL = 16
 FLAG_GENERATED_SOURCE = 32
 
+DIFF_STATUS_UNCHANGED = 0
+DIFF_STATUS_CHANGED = 1
+DIFF_STATUS_ADDED = 2
+DIFF_STATUS_REMOVED = 3
+
 
 class SizeInfo(object):
   """Represents all size information for a single binary.
 
   Fields:
     section_sizes: A dict of section_name -> size.
     raw_symbols: A list of all symbols, sorted by address.
     symbols: A SymbolGroup containing all symbols. By default, these are the
         same as raw_symbols, but may contain custom groupings when it is
         desirable to convey the result of a query along with section_sizes and
@@ skipping 220 matching lines @@
     return 'Group(full_name=%s,count=%d,size=%d)' % (
         self.full_name, len(self), self.size)
 
   def __iter__(self):
     return iter(self._symbols)
 
   def __len__(self):
     return len(self._symbols)
 
   def __eq__(self, other):
-    return self._symbols == other._symbols
+    return isinstance(other, SymbolGroup) and self._symbols == other._symbols
 
   def __getitem__(self, key):
     """|key| can be an index or an address.
 
     Raises if multiple symbols map to the address.
     """
     if isinstance(key, slice):
       return self._symbols.__getitem__(key)
     if isinstance(key, basestring) or key > len(self._symbols):
       found = self.WhereAddressInRange(key)
@@ skipping 329 matching lines @@
 class SymbolDiff(SymbolGroup):
   """A SymbolGroup subclass representing a diff of two other SymbolGroups.
 
   All Symbols contained within have a |size| which is actually the size delta.
   Additionally, metadata is kept about which symbols were added / removed /
   changed.
   """
   __slots__ = (
       '_added_ids',
       '_removed_ids',
+      '_diff_status',
+      '_changed_count',
   )
 
   def __init__(self, added, removed, similar):
     self._added_ids = set(id(s) for s in added)
     self._removed_ids = set(id(s) for s in removed)
+    self._diff_status = DIFF_STATUS_CHANGED
+    self._changed_count = None
     symbols = []
     symbols.extend(added)
     symbols.extend(removed)
     symbols.extend(similar)
     super(SymbolDiff, self).__init__(symbols)
 
   def __repr__(self):
     return '%s(%d added, %d removed, %d changed, %d unchanged, size=%d)' % (
         'SymbolGroup', self.added_count, self.removed_count, self.changed_count,
         self.unchanged_count, self.size)
 
   def _CreateTransformed(self, symbols, filtered_symbols=None, full_name=None,
                          template_name=None, name=None, section_name=None,
                          is_sorted=None):
-    # Printing sorts, so short-circuit the same symbols case.
-    if len(symbols) == len(self._symbols):
-      new_added_ids = self._added_ids
-      new_removed_ids = self._removed_ids
-    else:
-      old_added_ids = self._added_ids
-      old_removed_ids = self._removed_ids
-
-      def get_status(sym):
-        obj_id = id(sym)
-        if obj_id in old_added_ids:
-          return 0
-        if obj_id in old_removed_ids:
-          return 1
-        if sym.IsGroup():
-          first_status = get_status(sym[0])
-          if all(get_status(s) == first_status for s in sym[1:]):
-            return first_status
-        return 2
-
-      new_added_ids = set()
-      new_removed_ids = set()
+    new_added_ids = set()
+    new_removed_ids = set()
+    group_diff_status = DIFF_STATUS_UNCHANGED
+    changed_count = 0
+    if symbols:
+      group_diff_status = self.DiffStatus(symbols[0])
       for sym in symbols:
-        status = get_status(sym)
-        if status == 0:
+        status = self.DiffStatus(sym)
+        if status != group_diff_status:
+          group_diff_status = DIFF_STATUS_CHANGED
+        if status == DIFF_STATUS_ADDED:
           new_added_ids.add(id(sym))
-        elif status == 1:
+        elif status == DIFF_STATUS_REMOVED:
           new_removed_ids.add(id(sym))
+        elif status == DIFF_STATUS_CHANGED:
+          changed_count += 1
 
     ret = SymbolDiff.__new__(SymbolDiff)
     ret._added_ids = new_added_ids
     ret._removed_ids = new_removed_ids
+    ret._diff_status = group_diff_status
+    ret._changed_count = changed_count
     super(SymbolDiff, ret).__init__(
         symbols, filtered_symbols=filtered_symbols, full_name=full_name,
         template_name=template_name, name=name, section_name=section_name,
         is_sorted=is_sorted)
     return ret
 
   @property
   def added_count(self):
     return len(self._added_ids)
 
   @property
   def removed_count(self):
     return len(self._removed_ids)
 
   @property
   def changed_count(self):
-    not_changed = self.unchanged_count + self.added_count + self.removed_count
-    return len(self) - not_changed
+    if self._changed_count is None:
+      self._changed_count = sum(1 for s in self if self.IsChanged(s))
+    return self._changed_count
 
   @property
   def unchanged_count(self):
-    return sum(1 for s in self if self.IsSimilar(s) and s.size == 0)
+    return (len(self) - self.changed_count - self.added_count -
+            self.removed_count)
+
+  def DiffStatus(self, sym):
+    # Groups store their own status, computed during _CreateTransformed().
+    if sym.IsGroup():
+      return sym._diff_status
+    sym_id = id(sym)
+    if sym_id in self._added_ids:
+      return DIFF_STATUS_ADDED
+    if sym_id in self._removed_ids:
+      return DIFF_STATUS_REMOVED
+    # 0 --> unchanged
+    # 1 --> changed
+    return int(sym.size != 0)
+
+  def IsUnchanged(self, sym):
+    return self.DiffStatus(sym) == DIFF_STATUS_UNCHANGED
+
+  def IsChanged(self, sym):
+    return self.DiffStatus(sym) == DIFF_STATUS_CHANGED
 
   def IsAdded(self, sym):
-    return id(sym) in self._added_ids
-
-  def IsSimilar(self, sym):
-    key = id(sym)
-    return key not in self._added_ids and key not in self._removed_ids
+    return self.DiffStatus(sym) == DIFF_STATUS_ADDED
 
   def IsRemoved(self, sym):
-    return id(sym) in self._removed_ids
+    return self.DiffStatus(sym) == DIFF_STATUS_REMOVED
 
   def WhereNotUnchanged(self):
-    return self.Filter(lambda s: not self.IsSimilar(s) or s.size)
+    return self.Filter(lambda s: not self.IsUnchanged(s))
 
 
 def _ExtractPrefixBeforeSeparator(string, separator, count):
   idx = -len(separator)
   prev_idx = None
   for _ in xrange(count):
     idx = string.find(separator, idx + len(separator))
     if idx < 0:
       break
     prev_idx = idx
   return string[:prev_idx]
 
 
 def _ExtractSuffixAfterSeparator(string, separator, count):
   prev_idx = len(string) + 1
   for _ in xrange(count):
     idx = string.rfind(separator, 0, prev_idx - 1)
     if idx < 0:
       break
     prev_idx = idx
   return string[:prev_idx]