Rebuild when build-time/run-time deps are upgraded.

pym/_emerge/resolver/backtracking.py

 # Copyright 2010 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
 import copy
 
 class BacktrackParameter(object):
 
         __slots__ = (
                 "needed_unstable_keywords", "runtime_pkg_mask", "needed_use_config_changes", "needed_license_changes",
+                "rebuild_list", "reinstall_list"
         )
 
         def __init__(self):
                 self.needed_unstable_keywords = set()
                 self.runtime_pkg_mask = {}
                 self.needed_use_config_changes = {}
                 self.needed_license_changes = {}
+                self.rebuild_list = set()
+                self.reinstall_list = set()
 
         def __deepcopy__(self, memo=None):
                 if memo is None:
                         memo = {}
                 result = BacktrackParameter()
                 memo[id(self)] = result
 
                 #Shallow copies are enough here, as we only need to ensure that nobody adds stuff
                 #to our sets and dicts. The existing content is immutable.
                 result.needed_unstable_keywords = copy.copy(self.needed_unstable_keywords)
                 result.runtime_pkg_mask = copy.copy(self.runtime_pkg_mask)
                 result.needed_use_config_changes = copy.copy(self.needed_use_config_changes)
                 result.needed_license_changes = copy.copy(self.needed_license_changes)
+                result.rebuild_list = copy.copy(self.rebuild_list)
+                result.reinstall_list = copy.copy(self.reinstall_list)
 
                 return result
 
         def __eq__(self, other):
                 return self.needed_unstable_keywords == other.needed_unstable_keywords and \
                         self.runtime_pkg_mask == other.runtime_pkg_mask and \
                         self.needed_use_config_changes == other.needed_use_config_changes and \
-                        self.needed_license_changes == other.needed_license_changes
+                        self.needed_license_changes == other.needed_license_changes and \
+                        self.rebuild_list == other.rebuild_list and \
+                        self.reinstall_list == other.reinstall_list
 
 
 class _BacktrackNode:
 
         __slots__ = (
                 "parameter", "depth", "mask_steps", "terminal",
         )
 
         def __init__(self, parameter=BacktrackParameter(), depth=0, mask_steps=0, terminal=True):
                 self.parameter = parameter
@@ skipping 82 matching lines @@
 
                 for change, data in changes.items():
                         if change == "needed_unstable_keywords":
                                 para.needed_unstable_keywords.update(data)
                         elif change == "needed_license_changes":
                                 for pkg, missing_licenses in data:
                                         para.needed_license_changes.setdefault(pkg, set()).update(missing_licenses)
                         elif change == "needed_use_config_changes":
                                 for pkg, (new_use, new_changes) in data:
                                         para.needed_use_config_changes[pkg] = (new_use, new_changes)
+                        elif change == "rebuild_list":
+                                para.rebuild_list.update(data)
+                        elif change == "reinstall_list":
+                                para.reinstall_list.update(data)
 
                 self._add(new_node, explore=explore)
                 self._current_node = new_node
 
 
         def feedback(self, infos):
                 """
                 Takes information from the depgraph and computes new backtrack parameters to try.
                 """
                 assert self._current_node is not None, "call feedback() only after get() was called"
@@ skipping 22 matching lines @@
                 Like, get() but returns the backtrack parameter that has as many config changes as possible,
                 but has no masks. This makes --autounmask effective, but prevents confusing error messages
                 with "masked by backtracking".
                 """
                 best_node = self._root
                 for node in self._nodes:
                         if node.terminal and node.depth > best_node.depth:
                                 best_node = node
 
                 return copy.deepcopy(best_node.parameter)