supersize: Don't cluster by default. Make Diff() accept only SizeInfo.

tools/binary_size/libsupersize/diff.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.
 """Logic for diffing two SizeInfo objects."""
 
 import collections
 
 import models
 
 
@@ skipping 39 matching lines @@
 
     # If this is the first matched symbol of an alias group, initialize its
     # aliases list. The remaining aliases will be appended when diff'ed.
     if after_sym.aliases:
       ret.aliases = [ret]
       diffed_symbol_by_after_aliases[id(after_sym.aliases)] = ret
   return ret
 
 
 def _CloneUnmatched(after_symbols, diffed_symbol_by_after_aliases):
-  ret = []
-  for sym in after_symbols:
+  ret = [None] * len(after_symbols)
+  for i, sym in enumerate(after_symbols):
     cloned = sym
-    if sym.IsGroup():
-      cloned = models.SymbolDiff(
-          [], _CloneUnmatched(sym, diffed_symbol_by_after_aliases), [],
-          name=sym.name, full_name=sym.full_name, section_name=sym.section_name)
-    elif sym.aliases:
+    if sym.aliases:
       diffed_alias = diffed_symbol_by_after_aliases.get(id(sym.aliases))
       if diffed_alias:
         # At least one alias was diffed.
         cloned = _CloneAlias(sym, diffed_alias)
-    ret.append(cloned)
+    ret[i] = cloned
   return ret
 
 
 def _NegateAndClone(before_symbols, matched_before_aliases,
                     negated_symbol_by_before_aliases):
-  ret = []
-  for sym in before_symbols:
-    if sym.IsGroup():
-      cloned = models.SymbolDiff(
-          [], _NegateAndClone(sym, matched_before_aliases,
-                              negated_symbol_by_before_aliases), [],
-          name=sym.name, full_name=sym.full_name, section_name=sym.section_name)
+  ret = [None] * len(before_symbols)
+  for i, sym in enumerate(before_symbols):
+    if sym.aliases:
+      negated_alias = negated_symbol_by_before_aliases.get(id(sym.aliases))
+      if negated_alias:
+        cloned = _CloneAlias(sym, negated_alias)
+      else:
+        all_aliases_removed = id(sym.aliases) not in matched_before_aliases
+        # If all alises are removed, then given them negative size to reflect
+        # the savings.
+        if all_aliases_removed:
+          cloned = _CloneSymbol(sym, -sym.size_without_padding)
+          cloned.padding = -sym.padding
+        else:
+          # But if only a subset of aliases are removed, do not actually treat
+          # them as aliases anymore, or else they will weigh down the PSS of
+          # the symbols that were not removed.
+          cloned = _CloneSymbol(sym, 0)
+        cloned.aliases = [cloned]
+        negated_symbol_by_before_aliases[id(sym.aliases)] = cloned
     else:
-      negated_alias = None
-      if sym.aliases:
-        negated_alias = negated_symbol_by_before_aliases.get(id(sym.aliases))
-        if negated_alias:
-          cloned = _CloneAlias(sym, negated_alias)
-        else:
-          all_aliases_removed = id(sym.aliases) not in matched_before_aliases
-          # If all alises are removed, then given them negative size to reflect
-          # the savings.
-          if all_aliases_removed:
-            cloned = _CloneSymbol(sym, -sym.size_without_padding)
-            cloned.padding = -sym.padding
-          else:
-            # But if only a subset of aliases are removed, do not actually treat
-            # them as aliases anymore, or else they will weigh down the PSS of
-            # the symbols that were not removed.
-            cloned = _CloneSymbol(sym, 0)
-          cloned.aliases = [cloned]
-          negated_symbol_by_before_aliases[id(sym.aliases)] = cloned
-      else:
-        cloned = _CloneSymbol(sym, -sym.size_without_padding)
-        cloned.padding = -sym.padding
-    ret.append(cloned)
+      cloned = _CloneSymbol(sym, -sym.size_without_padding)
+      cloned.padding = -sym.padding
+    ret[i] = cloned
   return ret
 
 
-# TODO(agrieve): Diff logic does not work correctly when aliased symbols span
-#     mulitple groups. We should simplify by not allowing recursion (allow diffs
-#     only on SizeInfo, apply logic to raw_symbols, re-cluster after-the-fact.
 def _DiffSymbolGroups(before, after):
   before_symbols_by_key = collections.defaultdict(list)
   for s in before:
     before_symbols_by_key[s._Key()].append(s)
 
   similar = []
   diffed_symbol_by_after_aliases = {}
   matched_before_aliases = set()
   unmatched_after_syms = []
   # For similar symbols, padding is zeroed out. In order to not lose the
@@ skipping 31 matching lines @@
   for section_name, padding in padding_by_section_name.iteritems():
     if padding != 0:
       similar.append(models.Symbol(
           section_name, padding,
           name="** aggregate padding of diff'ed symbols"))
   return models.SymbolDiff(
       added, removed, similar, name=after.name, full_name=after.full_name,
       section_name=after.section_name)
 
 
-def Diff(before, after):
-  """Diffs two SizeInfo or SymbolGroup objects.
+def Diff(before, after, cluster=True):
+  """Diffs two SizeInfo objects. Returns a SizeInfoDiff.
 
-  When diffing SizeInfos, a SizeInfoDiff is returned.
-  When diffing SymbolGroups, a SymbolDiff is returned.
-
-  Returns:
-    Returns a SizeInfo when args are of type SizeInfo.
-    Returns a SymbolDiff when args are of type SymbolGroup.
+  Args:
+    cluster: When True, calls SymbolGroup.Cluster() after diffing. This
+        generally reduces noise.
   """
-  if isinstance(after, models.SizeInfo):
-    assert isinstance(before, models.SizeInfo)
-    section_sizes = {k: after.section_sizes[k] - v
-                     for k, v in before.section_sizes.iteritems()}
-    symbol_diff = _DiffSymbolGroups(before.symbols, after.symbols)
-    return models.SizeInfoDiff(section_sizes, symbol_diff, before.metadata,
-                               after.metadata)
-
-  assert (isinstance(after, models.SymbolGroup) and
-          isinstance(before, models.SymbolGroup))
-  return _DiffSymbolGroups(before, after)
-
-
+  assert isinstance(before, models.SizeInfo)
+  assert isinstance(after, models.SizeInfo)
+  section_sizes = {k: after.section_sizes[k] - v
+                   for k, v in before.section_sizes.iteritems()}
+  symbol_diff = _DiffSymbolGroups(before.symbols, after.symbols)
+  if cluster:
+    symbol_diff = symbol_diff.Cluster()
+  return models.SizeInfoDiff(section_sizes, symbol_diff, before.metadata,
+                             after.metadata)