This function allows emerge to solve more slot conflicts without
backtracking.
It does this by creating more conflicts for packages with built slot
operator dependencies. This gives more freedom to
depgraph._solve_non_slot_operator_slot_conflicts, which is then able
to solve conflicts it wouldn't have otherwise.
---
pym/_emerge/depgraph.py | 483 +++++++++++++++++++++++++++++++++++------
pym/_emerge/resolver/output.py | 5 +-
2 files changed, 415 insertions(+), 73 deletions(-)
diff --git a/pym/_emerge/depgraph.py b/pym/_emerge/depgraph.py
index 835bd6b..970a9c7 100644
--- a/pym/_emerge/depgraph.py
+++ b/pym/_emerge/depgraph.py
@@ -427,6 +427,12 @@ class _dynamic_depgraph_config(object):
# Track missed updates caused by solved conflicts.
self._conflict_missed_update = collections.defaultdict(dict)
+ # Rebuilds caused by slot conflicts.
+ self._slot_conflict_rebuilds = {}
+ # Rebuilds caused by missed slot operator updates or
+ # slot conflicts.
+ self._forced_rebuilds = None
+
for myroot in depgraph._frozen_config.trees:
self.sets[myroot] = _depgraph_sets()
vardb =
depgraph._frozen_config.trees[myroot]["vartree"].dbapi
@@ -614,6 +620,9 @@ class depgraph(object):
Fill self._forced_rebuilds with packages that cause rebuilds.
"""
+ if self._dynamic_config._forced_rebuilds is not None:
+ return
+
debug = "--debug" in self._frozen_config.myopts
# Get all atoms that might have caused a forced rebuild.
@@ -687,19 +696,23 @@ class depgraph(object):
writemsg_level("\n\n",
level=logging.DEBUG, noiselevel=-1)
- self._forced_rebuilds = forced_rebuilds
+ for child, parents in
self._dynamic_config._slot_conflict_rebuilds.items():
+ forced_rebuilds.setdefault(child.root,
{}).setdefault(child, set()).update(parents)
+
+ self._dynamic_config._forced_rebuilds = forced_rebuilds
def _show_abi_rebuild_info(self):
- if not self._forced_rebuilds:
+ forced_rebuilds = self._dynamic_config._forced_rebuilds
+ if not forced_rebuilds:
return
writemsg_stdout("\nThe following packages are causing
rebuilds:\n\n", noiselevel=-1)
- for root in self._forced_rebuilds:
- for child in self._forced_rebuilds[root]:
+ for root in forced_rebuilds:
+ for child in forced_rebuilds[root]:
writemsg_stdout(" %s causes rebuilds for:\n" %
(child,), noiselevel=-1)
- for parent in
self._forced_rebuilds[root][child]:
+ for parent in forced_rebuilds[root][child]:
writemsg_stdout(" %s\n" % (parent,),
noiselevel=-1)
def _show_ignored_binaries(self):
@@ -968,16 +981,16 @@ class depgraph(object):
writemsg(line + '\n', noiselevel=-1)
writemsg('\n', noiselevel=-1)
- def _solve_non_slot_operator_slot_conflicts(self):
+
+ def _extend_slot_operator_conflicts(self):
"""
- This function solves slot conflicts which can
- be solved by simply choosing one of the conflicting
- and removing all the other ones.
- It is able to solve somewhat more complex cases where
- conflicts can only be solved simultaniously.
+ This function searches for packages that cause
+ slot conflicts by dependening on conflict packages
+ with built slot operator deps. If such a package
+ is found an alternative package is pulled in with
+ the hope that the alternative package would not
+ cuase the slot conflict.
"""
- debug = "--debug" in self._frozen_config.myopts
-
# List all conflicts. Ignore those that involve slot operator
rebuilds
# as the logic there needs special slot conflict behavior which
isn't
# provided by this function.
@@ -990,9 +1003,133 @@ class depgraph(object):
if not conflicts:
return
- # Get a set of all conflicting packages.
+ # Compute a mapping from parent packages to hard
+ # required conflict packages.
+ conflict_parents = collections.defaultdict(list)
+ for conflict in conflicts:
+ all_parent_atoms = set()
+ for pkg in conflict:
+ all_parent_atoms.update(
+
self._dynamic_config._parent_atoms.get(pkg, []))
+
+ for parent, atom in all_parent_atoms:
+ atom_set = InternalPackageSet(
+ initial_atoms=(atom,), allow_repo=True)
+
+ for pkg in conflict:
+ if not atom_set.findAtomForPackage(pkg,
\
+
modified_use=self._pkg_use_enabled(pkg)):
+
conflict_parents[parent].append((pkg, atom))
+
+ def _iter_alternatives(pkg):
+ """
+ A wrapper around _iter_similar_available that
+ deals with autounmask.
+ """
+ tried = set()
+ for other in self._iter_similar_available(pkg,
+ Atom(pkg.cp), autounmask_level=None,
installed=False):
+ tried.add(other)
+ yield other, None
+
+ if self._dynamic_config._autounmask is not True:
+ return
+
+ for autounmask_level in self._autounmask_levels():
+ for other in self._iter_similar_available(pkg,
+ Atom(pkg.cp),
autounmask_level=autounmask_level, installed=False):
+ if other not in tried:
+ tried.add(other)
+ yield other, autounmask_level
+
+
+ # Compute a list of possible alternatives
+ # for each conflict parent.
+ parent_matches = {}
+ for parent in conflict_parents:
+ slot_op_children = []
+ for child, atom in conflict_parents[parent]:
+ if atom.slot_operator == "=" and parent.built:
+ slot_op_children.append(child)
+
+ if not slot_op_children:
+ # This parent doesn't depend with a built slot
+ # operator on a conflict package.
+ continue
+
+ matches = []
+ highest_ebuilds = {}
+ for other, autounmask_level in
_iter_alternatives(parent):
+ if parent.slot_atom != other.slot_atom and
parent.cpv != other.cpv:
+ # 'other' is not a replacement for
'parent'.
+ continue
+
+ highest_ebuild =
highest_ebuilds.get(autounmask_level)
+ if not other.built and \
+ (highest_ebuild is None or
highest_ebuild < other):
+ # Remember the highest ebuild for
+ # downgrade testing later.
+ highest_ebuilds[autounmask_level] =
other
+
+ # Go through 'parents' parents and check if
'other'
+ # satisfies their dependencies. Ignore built
slot
+ # operator deps.
+ is_match = True
+ for pparent, patom in
self._dynamic_config._parent_atoms.get(parent, []):
+ if patom.slot_operator == "=" and
pparent.built and parent.built:
+ continue
+
+ atom_set = InternalPackageSet(
+ initial_atoms=(patom,),
allow_repo=True)
+
+ if not
atom_set.findAtomForPackage(other, \
+
modified_use=self._pkg_use_enabled(other)):
+ is_match = False
+ break
+
+ if is_match:
+ matches.append((other,
autounmask_level))
+
+ # Filter downgrades.
+ no_downgrade_matches = []
+ for match, autounmask_level in matches:
+ highest_ebuild =
highest_ebuilds.get(autounmask_level)
+ if highest_ebuild and match >= highest_ebuild:
+ no_downgrade_matches.append(match)
+
+ parent_matches[parent] = no_downgrade_matches
+
+ # Pull in alternatives.
+ for parent in parent_matches:
+ for match in parent_matches[parent]:
+ other.depth = parent.depth
+ dep = Dependency(atom=Atom('=' + match.cpv),
child=match,
+ parent=None, root=match.root)
+
+ if not self._add_pkg(match, dep,
reuse_existing=False) or \
+ not self._create_graph():
+ self._remove_pkg(match)
+ continue
+
+ # Record forces rebuilds.
+ for child, atom in conflict_parents[parent]:
+
self._dynamic_config._slot_conflict_rebuilds.setdefault(
+ child, set()).add(match)
+ break
+
+
+ def _get_conflicts_data(self, conflicts):
+ """
+ This function creates the conflict graph and some
+ helper data structures for
_solve_non_slot_operator_slot_conflicts.
+ """
+ selective = "selective" in self._dynamic_config.myparams
+
+ pkg_to_conflict = {}
conflict_pkgs = set()
for conflict in conflicts:
+ for pkg in conflict:
+ pkg_to_conflict[pkg] = conflict
conflict_pkgs.update(conflict)
# Get the list of other packages which are only
@@ -1050,7 +1187,7 @@ class depgraph(object):
self._dynamic_config._parent_atoms.get(pkg, []))
for parent, atom in all_parent_atoms:
- is_arg_parent = isinstance(parent, AtomArg)
+ is_arg_parent = isinstance(parent, AtomArg) and
not selective
if parent not in conflict_pkgs and \
parent not in indirect_conflict_pkgs:
@@ -1072,7 +1209,11 @@ class depgraph(object):
conflict_graph.add(matched[0], parent)
else:
# More than one packages matched, but
not all.
- conflict_graph.add(or_tuple(matched),
parent)
+ match_tuple = or_tuple(matched)
+ conflict_graph.add(match_tuple, parent)
+ for match in matched:
+ conflict_graph.add(match,
match_tuple)
+
for pkg in indirect_conflict_pkgs:
for parent, atom in
self._dynamic_config._parent_atoms.get(pkg, []):
@@ -1081,6 +1222,42 @@ class depgraph(object):
parent = non_conflict_node
conflict_graph.add(pkg, parent)
+ for conflict in conflicts:
+ if all(not conflict_graph.parent_nodes(node) for node
in conflict):
+ # No conflict parents, all parents accept all
conflict packages.
+ # This happens when
_extend_slot_operator_conflict pulls in
+ # alternative parents for other conflict
paclages.
+ conflict_graph.add(or_tuple(conflict),
non_conflict_node)
+
+ return conflict_graph, pkg_to_conflict, conflict_pkgs,
non_conflict_node
+
+
+ def _solve_non_slot_operator_slot_conflicts(self):
+ """
+ This function solves slot conflicts which can
+ be solved by simply choosing one of the conflicting
+ packages and removing all the other ones.
+ It is able to solve somewhat more complex cases where
+ conflicts can only be solved simultaniously.
+ """
+ debug = "--debug" in self._frozen_config.myopts
+ selective = "selective" in self._dynamic_config.myparams
+
+ # List all conflicts. Ignore those that involve slot operator
rebuilds
+ # as the logic there needs special slot conflict behavior which
isn't
+ # provided by this function.
+ conflicts = []
+ for conflict in
self._dynamic_config._package_tracker.slot_conflicts():
+ slot_key = conflict.root, conflict.atom
+ if slot_key not in
self._dynamic_config._slot_operator_replace_installed:
+ conflicts.append(conflict)
+
+ if not conflicts:
+ return
+
+ conflict_graph, pkg_to_conflict, conflict_pkgs,
non_conflict_node = \
+ self._get_conflicts_data(conflicts)
+
if debug:
writemsg_level(
"\n!!! Slot conflict graph:\n",
@@ -1091,14 +1268,20 @@ class depgraph(object):
# 'forced' set.
forced = set([non_conflict_node])
unexplored = set([non_conflict_node])
+ # Keep track of packages for which another conflicting
+ # package has already been choosen. Discourage those
+ # in case the choice between several packages has to be
+ # made.
+ discouraged = set()
# or_tuples get special handling. We first explore
# all packages in the hope of having forced one of
# the packages in the tuple. This way we don't have
# to choose one.
unexplored_tuples = set()
- while unexplored:
+ while unexplored or unexplored_tuples:
# Handle all unexplored packages.
+ new_discouraged = set()
while unexplored:
node = unexplored.pop()
for child in conflict_graph.child_nodes(node):
@@ -1107,30 +1290,129 @@ class depgraph(object):
forced.add(child)
if isinstance(child, Package):
unexplored.add(child)
+ for other in
pkg_to_conflict.get(child, []):
+ if other in forced or
other in discouraged:
+ continue
+
new_discouraged.add(other)
else:
unexplored_tuples.add(child)
+ for other in
pkg_to_conflict[child[0]]:
+ if other in child:
+ continue
+ if other in forced or
other in discouraged:
+ continue
+
new_discouraged.add(other)
+
+ # Now mark packages which aren't forced yet
+ # but would cause a conflict if they were as
+ # discouraged.
+ while new_discouraged:
+ pkg = new_discouraged.pop()
+ discouraged.add(pkg)
+ for parent in conflict_graph.parent_nodes(pkg):
+ if parent in forced or parent in
discouraged:
+ continue
+ if isinstance(parent, Package):
+ new_discouraged.add(parent)
+ else:
+ if all(other in discouraged and
other not in forced \
+ for other in parent):
+
new_discouraged.add(parent)
# Now handle unexplored or_tuples. Move on with packages
# once we had to choose one.
- while unexplored_tuples:
- nodes = unexplored_tuples.pop()
+ remaining_unexplored_tuples = set()
+ for nodes in unexplored_tuples:
if any(node in forced for node in nodes):
- # At least one of the packages in the
- # tuple is already forced, which means
the
- # dependency represented by this tuple
- # is satisfied.
+ # Already satisfied.
continue
- # We now have to choose one of packages in the
tuple.
- # In theory one could solve more conflicts if
we'd be
- # able to try different choices here, but that
has lots
- # of other problems. For now choose the package
that was
- # pulled first, as this should be the most
desirable choice
- # (otherwise it wouldn't have been the first
one).
- forced.add(nodes[0])
- unexplored.add(nodes[0])
+ is_superset = False
+ for other_nodes in unexplored_tuples:
+ if other_nodes is nodes:
+ continue
+ if set(other_nodes).issubset(nodes):
+ is_superset = True
+ break
+ if is_superset:
+ continue
+
+ non_dicouraged = list(node for node in nodes \
+ if node not in discouraged)
+
+ if len(non_dicouraged) == 1:
+ forced.add(non_dicouraged[0])
+ unexplored.add(non_dicouraged[0])
+ continue
+
+ remaining_unexplored_tuples.add(nodes)
+
+ unexplored_tuples = remaining_unexplored_tuples
+ if unexplored:
+ continue
+
+ # For each package compute if it is discouraged
+ # and if all its dependencies are already forced.
+ status = collections.defaultdict(set)
+ for nodes in unexplored_tuples:
+ for node in nodes:
+ is_discouraged = node in discouraged
+
+ is_satisfied = True
+ for child in
conflict_graph.child_nodes(node):
+ if isinstance(child, Package):
+ if child not in forced:
+ is_satisfied =
False
+ break
+ else:
+ if any(child_node not
in forced for child_node in child):
+ is_satisfied =
False
+ break
+ status[(not is_discouraged,
is_satisfied)].add(node)
+
+ # Go through the state combinations to find
+ # an or_tuple with the least chance of
+ # causing a conflict. At this point we resort to
+ # educted guessing and force one package.
+ for state in (True, True), (True, False), (False,
True), (False, False):
+ selected = {}
+ for nodes in unexplored_tuples:
+ candidates = []
+ for node in nodes:
+ if node in status[state]:
+ candidates.append(node)
+ if candidates:
+ selected[nodes] = candidates
+
+ # Search for the or_tuple with the least
+ # number of candidates.
+ choosen = None
+ for nodes in selected:
+ candidates = selected[nodes]
+ if choosen is None or len(choosen) >
len(candidates):
+ choosen = candidates
+
+ if not choosen:
+ continue
+
+ if selective:
+ # Prefer installed packages.
+ selected = None
+ for node in choosen:
+ if node.installed:
+ selected = node
+ break
+ if selected is None:
+ selected = choosen[0]
+ else:
+ # Prefer the first package.
+ selected = choosen[0]
+
+ forced.add(selected)
+ unexplored.add(selected)
break
+
# Remove 'non_conflict_node' and or_tuples from 'forced'.
forced = set(pkg for pkg in forced if isinstance(pkg, Package))
non_forced = set(pkg for pkg in conflict_pkgs if pkg not in
forced)
@@ -1206,9 +1488,10 @@ class depgraph(object):
If there are any slot conflicts and backtracking is enabled,
_complete_graph should complete the graph before this method
is called, so that all relevant reverse dependencies are
- available for use in backtracking decisions.
+ available for use during conflict resolution.
"""
-
+ self._solve_non_slot_operator_slot_conflicts()
+ self._extend_slot_operator_conflicts()
self._solve_non_slot_operator_slot_conflicts()
for conflict in
self._dynamic_config._package_tracker.slot_conflicts():
@@ -1842,7 +2125,7 @@ class depgraph(object):
return frozenset(x.unevaluated_atom for
x in selected_atoms)
- def _iter_similar_available(self, graph_pkg, atom,
autounmask_level=None):
+ def _iter_similar_available(self, graph_pkg, atom,
autounmask_level=None, installed=False):
"""
Given a package that's in the graph, do a rough check to
see if a similar package is available to install. The given
@@ -1859,7 +2142,7 @@ class depgraph(object):
if pkg.cp != graph_pkg.cp:
# discard old-style virtual match
continue
- if pkg.installed:
+ if pkg.installed and not installed:
continue
if pkg in self._dynamic_config._runtime_pkg_mask:
continue
@@ -2176,7 +2459,7 @@ class depgraph(object):
return (existing_node, matches)
- def _add_pkg(self, pkg, dep):
+ def _add_pkg(self, pkg, dep, reuse_existing=True):
"""
Adds a package to the depgraph, queues dependencies, and handles
slot conflicts.
@@ -2268,7 +2551,7 @@ class depgraph(object):
existing_node, existing_node_matches = \
self._check_slot_conflict(pkg, dep.atom)
if existing_node:
- if existing_node_matches:
+ if existing_node_matches and reuse_existing:
# The existing node can be reused.
if pkg != existing_node:
pkg = existing_node
@@ -2415,14 +2698,19 @@ class depgraph(object):
pass
# Remove slot operator dependencies.
- slot_key = (pkg.root, pkg.slot_atom)
- if slot_key in self._dynamic_config._slot_operator_deps:
+ for slot_key in
list(self._dynamic_config._slot_operator_deps.keys()):
self._dynamic_config._slot_operator_deps[slot_key] = \
[dep for dep in
self._dynamic_config._slot_operator_deps[slot_key] \
- if dep.child is not pkg]
+ if dep.child is not pkg and dep.parent is not
pkg]
if not
self._dynamic_config._slot_operator_deps[slot_key]:
del
self._dynamic_config._slot_operator_deps[slot_key]
+ # Rebuild tracking data structures.
+ self._dynamic_config._forced_rebuilds = None
+ self._dynamic_config._slot_conflict_rebuilds.pop(pkg, None)
+ for child in self._dynamic_config._slot_conflict_rebuilds:
+
self._dynamic_config._slot_conflict_rebuilds[child].discard(pkg)
+
# Remove blockers.
self._dynamic_config._blocker_parents.discard(pkg)
self._dynamic_config._irrelevant_blockers.discard(pkg)
@@ -2430,6 +2718,13 @@ class depgraph(object):
self._dynamic_config._blocked_pkgs.discard(pkg)
self._dynamic_config._blocked_world_pkgs.pop(pkg, None)
+ # Remove package's unsatisfied dependencies.
+ _unsatisfied_deps_for_display = []
+ for (root, atom), info in
self._dynamic_config._unsatisfied_deps_for_display:
+ if info["myparent"] is not pkg:
+ _unsatisfied_deps_for_display.append(((root,
atom), info))
+ self._dynamic_config._unsatisfied_deps_for_display =
_unsatisfied_deps_for_display
+
for child in children:
if not self._dynamic_config.digraph.parent_nodes(child):
self._remove_pkg(child)
@@ -5630,6 +5925,63 @@ class depgraph(object):
return pkg, in_graph
+ def _enable_complete_mode(self):
+ """
+ Put the depgraph into a mode that causes it to only
+ select packages that have already been added to the
+ graph or those that are installed and have not been
+ scheduled for replacement. Also, toggle the "deep"
+ parameter so that all dependencies are traversed and
+ accounted for.
+ """
+
+ previous_state = {}
+ previous_state["complete_mode"] =
self._dynamic_config._complete_mode
+ previous_state["_select_atoms"] = self._select_atoms
+ previous_state["_select_package"] = self._select_package
+ previous_state["_traverse_ignored_deps"] = \
+ self._dynamic_config._traverse_ignored_deps
+ previous_state["deep"] =
self._dynamic_config.myparams.get("deep")
+
+ self._dynamic_config._complete_mode = True
+ self._select_atoms = self._select_atoms_from_graph
+ if "remove" in self._dynamic_config.myparams:
+ self._select_package = self._select_pkg_from_installed
+ else:
+ self._select_package = self._select_pkg_from_graph
+ self._dynamic_config._traverse_ignored_deps = True
+ already_deep = self._dynamic_config.myparams.get("deep") is True
+ if not already_deep:
+ self._dynamic_config.myparams["deep"] = True
+
+ # Invalidate the package selection cache, since
+ # _select_package has just changed implementations.
+ for trees in self._dynamic_config._filtered_trees.values():
+ trees["porttree"].dbapi._clear_cache()
+
+ return previous_state
+
+ def _disable_complete_mode(self, previous_state):
+ """
+ Reverts the changes made by _enable_complete_mode.
+ """
+ self._dynamic_config._complete_mode =
previous_state["complete_mode"]
+ self._select_atoms = previous_state["_select_atoms"]
+ self._select_package = previous_state["_select_package"]
+ self._dynamic_config._traverse_ignored_deps = \
+ previous_state["_traverse_ignored_deps"]
+
+ if previous_state["deep"] is None:
+ del self._dynamic_config.myparams["deep"]
+ else:
+ self._dynamic_config.myparams["deep"] =
previous_state["deep"]
+
+ # Invalidate the package selection cache, since
+ # _select_package has just changed implementations.
+ for trees in self._dynamic_config._filtered_trees.values():
+ trees["porttree"].dbapi._clear_cache()
+
+
def _complete_graph(self, required_sets=None):
"""
Add any deep dependencies of required sets (args, system,
world) that
@@ -5713,27 +6065,8 @@ class depgraph(object):
self._load_vdb()
- # Put the depgraph into a mode that causes it to only
- # select packages that have already been added to the
- # graph or those that are installed and have not been
- # scheduled for replacement. Also, toggle the "deep"
- # parameter so that all dependencies are traversed and
- # accounted for.
- self._dynamic_config._complete_mode = True
- self._select_atoms = self._select_atoms_from_graph
- if "remove" in self._dynamic_config.myparams:
- self._select_package = self._select_pkg_from_installed
- else:
- self._select_package = self._select_pkg_from_graph
- self._dynamic_config._traverse_ignored_deps = True
- already_deep = self._dynamic_config.myparams.get("deep") is True
- if not already_deep:
- self._dynamic_config.myparams["deep"] = True
-
- # Invalidate the package selection cache, since
- # _select_package has just changed implementations.
- for trees in self._dynamic_config._filtered_trees.values():
- trees["porttree"].dbapi._clear_cache()
+ previous_state = self._enable_complete_mode()
+ already_deep = previous_state["deep"] is True
args = self._dynamic_config._initial_arg_list[:]
for root in self._frozen_config.roots:
@@ -5778,12 +6111,12 @@ class depgraph(object):
Dependency(atom=atom,
root=arg.root_config.root,
parent=arg))
- if True:
- if self._dynamic_config._ignored_deps:
-
self._dynamic_config._dep_stack.extend(self._dynamic_config._ignored_deps)
- self._dynamic_config._ignored_deps = []
- if not self._create_graph(allow_unsatisfied=True):
- return 0
+ if self._dynamic_config._ignored_deps:
+
self._dynamic_config._dep_stack.extend(self._dynamic_config._ignored_deps)
+ self._dynamic_config._ignored_deps = []
+
+ ret = 1
+ if self._create_graph(allow_unsatisfied=True):
# Check the unsatisfied deps to see if any initially
satisfied deps
# will become unsatisfied due to an upgrade. Initially
unsatisfied
# deps are irrelevant since we only want to avoid
breaking deps
@@ -5802,10 +6135,17 @@ class depgraph(object):
# (possibly solvable via backtracking).
pkg = matches[-1] # highest match
if not self._add_pkg(pkg, dep):
- return 0
+ ret = 0
+ break
if not
self._create_graph(allow_unsatisfied=True):
- return 0
- return 1
+ ret = 0
+ break
+ else:
+ ret = 0
+
+ self._disable_complete_mode(previous_state)
+
+ return ret
def _pkg(self, cpv, type_name, root_config, installed=False,
onlydeps=False, myrepo = None):
@@ -7285,8 +7625,9 @@ class depgraph(object):
if "--tree" in self._frozen_config.myopts:
mylist = tuple(reversed(mylist))
- display = Display()
+ self._compute_abi_rebuild_info()
+ display = Display()
return display(self, mylist, favorites, verbosity)
def _display_autounmask(self):
diff --git a/pym/_emerge/resolver/output.py b/pym/_emerge/resolver/output.py
index 5f550be..72a1ec2 100644
--- a/pym/_emerge/resolver/output.py
+++ b/pym/_emerge/resolver/output.py
@@ -836,8 +836,9 @@ class Display(object):
self._get_installed_best(pkg, pkg_info)
if ordered and pkg_info.merge and \
not pkg_info.attr_display.new:
- for arg, atom in
depgraph._iter_atoms_for_pkg(pkg):
- if arg.force_reinstall:
+ forced_rebuilds =
depgraph._dynamic_config._forced_rebuilds.get(pkg.root, {})
+ for child in forced_rebuilds:
+ if pkg in
forced_rebuilds[child]:
pkg_info.attr_display.force_reinstall = True
break
--
1.8.3.2
