Rename slot-abi stuff to refer to slot-operator.

This makes it consistent with the language in the PMS eapi-5 branch:
http://git.overlays.gentoo.org/gitweb/?p=proj/pms.git;a=commit;h=5d6749ac9e5ddc5b1daaad7737b65fa81c6ece47

8 files changed, 94 insertions, 94 deletions

diff --git a/pym/_emerge/FakeVartree.py b/pym/_emerge/FakeVartree.py
index ce15f5a36..386501586 100644
--- a/pym/_emerge/FakeVartree.py
+++ b/pym/_emerge/FakeVartree.py
@@ -10,7 +10,7 @@ from _emerge.Package import Package
 from _emerge.PackageVirtualDbapi import PackageVirtualDbapi
 from portage.const import VDB_PATH
 from portage.dbapi.vartree import vartree
-from portage.dep._slot_abi import find_built_slot_abi_atoms
+from portage.dep._slot_abi import find_built_slot_operator_atoms
 from portage.eapi import _get_eapi_attrs
 from portage.exception import InvalidDependString
 from portage.repository.config import _gen_valid_repo
@@ -45,10 +45,10 @@ class FakeVartree(vartree):
 	is not a matching ebuild in the tree). Instances of this class are not
 	populated until the sync() method is called."""
 	def __init__(self, root_config, pkg_cache=None, pkg_root_config=None,
-		dynamic_deps=True, ignore_built_slot_abi_deps=False):
+		dynamic_deps=True, ignore_built_slot_operator_deps=False):
 		self._root_config = root_config
 		self._dynamic_deps = dynamic_deps
-		self._ignore_built_slot_abi_deps = ignore_built_slot_abi_deps
+		self._ignore_built_slot_operator_deps = ignore_built_slot_operator_deps
 		if pkg_root_config is None:
 			pkg_root_config = self._root_config
 		self._pkg_root_config = pkg_root_config
@@ -112,11 +112,11 @@ class FakeVartree(vartree):
 		installed_eapi = pkg_obj.metadata['EAPI']
 		repo = pkg_obj.metadata['repository']
 		eapi_attrs = _get_eapi_attrs(installed_eapi)
-		built_slot_abi_atoms = None
+		built_slot_operator_atoms = None
 
-		if eapi_attrs.slot_abi and not self._ignore_built_slot_abi_deps:
+		if eapi_attrs.slot_operator and not self._ignore_built_slot_operator_deps:
 			try:
-				built_slot_abi_atoms = find_built_slot_abi_atoms(pkg_obj)
+				built_slot_operator_atoms = find_built_slot_operator_atoms(pkg_obj)
 			except InvalidDependString:
 				pass
 
@@ -137,12 +137,12 @@ class FakeVartree(vartree):
 				portage.eapi_is_supported(installed_eapi)):
 				raise KeyError(pkg)
 
-			# preserve built SLOT/ABI := operator deps
-			if built_slot_abi_atoms:
+			# preserve built slot/sub-slot := operator deps
+			if built_slot_operator_atoms:
 				live_eapi_attrs = _get_eapi_attrs(live_metadata["EAPI"])
-				if not live_eapi_attrs.slot_abi:
+				if not live_eapi_attrs.slot_operator:
 					raise KeyError(pkg)
-				for k, v in built_slot_abi_atoms.items():
+				for k, v in built_slot_operator_atoms.items():
 					live_metadata[k] += (" " +
 						" ".join(_unicode(atom) for atom in v))
 
diff --git a/pym/_emerge/Package.py b/pym/_emerge/Package.py
index ce51a8b06..957d5d399 100644
--- a/pym/_emerge/Package.py
+++ b/pym/_emerge/Package.py
@@ -29,7 +29,7 @@ class Package(Task):
 		"root_config", "type_name",
 		"category", "counter", "cp", "cpv_split",
 		"inherited", "iuse", "mtime",
-		"pf", "root", "slot", "slot_abi", "slot_atom", "version") + \
+		"pf", "root", "slot", "sub_slot", "slot_atom", "version") + \
 		("_invalid", "_raw_metadata", "_masks", "_use",
 		"_validated_atoms", "_visible")
 
@@ -61,7 +61,7 @@ class Package(Task):
 				"SLOT: invalid value: '%s'" % self.metadata["SLOT"])
 		self.cp = self.cpv.cp
 		self.slot = self.cpv.slot
-		self.slot_abi = self.cpv.slot_abi
+		self.sub_slot = self.cpv.sub_slot
 		# sync metadata with validated repo (may be UNKNOWN_REPO)
 		self.metadata['repository'] = self.cpv.repo
 
diff --git a/pym/_emerge/Scheduler.py b/pym/_emerge/Scheduler.py
index d40cedd7b..8ee9a5841 100644
--- a/pym/_emerge/Scheduler.py
+++ b/pym/_emerge/Scheduler.py
@@ -328,15 +328,15 @@ class Scheduler(PollScheduler):
 		self._set_graph_config(graph_config)
 		self._blocker_db = {}
 		dynamic_deps = self.myopts.get("--dynamic-deps", "y") != "n"
-		ignore_built_slot_abi_deps = self.myopts.get(
-			"--ignore-built-slot-abi-deps", "n") == "y"
+		ignore_built_slot_operator_deps = self.myopts.get(
+			"--ignore-built-slot-operator-deps", "n") == "y"
 		for root in self.trees:
 			if self._uninstall_only:
 				continue
 			if graph_config is None:
 				fake_vartree = FakeVartree(self.trees[root]["root_config"],
 					pkg_cache=self._pkg_cache, dynamic_deps=dynamic_deps,
-					ignore_built_slot_abi_deps=ignore_built_slot_abi_deps)
+					ignore_built_slot_operator_deps=ignore_built_slot_operator_deps)
 				fake_vartree.sync()
 			else:
 				fake_vartree = graph_config.trees[root]['vartree']
diff --git a/pym/_emerge/create_depgraph_params.py b/pym/_emerge/create_depgraph_params.py
index 2838e93c3..98a76460c 100644
--- a/pym/_emerge/create_depgraph_params.py
+++ b/pym/_emerge/create_depgraph_params.py
@@ -15,11 +15,11 @@ def create_depgraph_params(myopts, myaction):
 	# complete:  completely account for all known dependencies
 	# remove:    build graph for use in removing packages
 	# rebuilt_binaries: replace installed packages with rebuilt binaries
-	# rebuild_if_new_slot_abi: rebuild or reinstall packages when
-	#	SLOT/ABI := operator dependencies can be satisfied by a newer
-	#	SLOT/ABI, so that older packages slots will become eligible for
+	# rebuild_if_new_slot: rebuild or reinstall packages when
+	#	slot/sub-slot := operator dependencies can be satisfied by a newer
+	#	slot/sub-slot, so that older packages slots will become eligible for
 	#	removal by the --depclean action as soon as possible
-	# ignore_built_slot_abi_deps: ignore the SLOT/ABI := operator parts
+	# ignore_built_slot_operator_deps: ignore the slot/sub-slot := operator parts
 	#	of dependencies that have been recorded when packages where built
 	myparams = {"recurse" : True}
 
@@ -27,9 +27,9 @@ def create_depgraph_params(myopts, myaction):
 	if bdeps is not None:
 		myparams["bdeps"] = bdeps
 
-	ignore_built_slot_abi_deps = myopts.get("--ignore-built-slot-abi-deps")
-	if ignore_built_slot_abi_deps is not None:
-		myparams["ignore_built_slot_abi_deps"] = ignore_built_slot_abi_deps
+	ignore_built_slot_operator_deps = myopts.get("--ignore-built-slot-operator-deps")
+	if ignore_built_slot_operator_deps is not None:
+		myparams["ignore_built_slot_operator_deps"] = ignore_built_slot_operator_deps
 
 	dynamic_deps = myopts.get("--dynamic-deps")
 	if dynamic_deps is not None:
@@ -41,9 +41,9 @@ def create_depgraph_params(myopts, myaction):
 		myparams["selective"] = True
 		return myparams
 
-	rebuild_if_new_slot_abi = myopts.get('--rebuild-if-new-slot-abi')
-	if rebuild_if_new_slot_abi is not None:
-		myparams['rebuild_if_new_slot_abi'] = rebuild_if_new_slot_abi
+	rebuild_if_new_slot = myopts.get('--rebuild-if-new-slot')
+	if rebuild_if_new_slot is not None:
+		myparams['rebuild_if_new_slot'] = rebuild_if_new_slot
 
 	if "--update" in myopts or \
 		"--newuse" in myopts or \
diff --git a/pym/_emerge/depgraph.py b/pym/_emerge/depgraph.py
index 5c49e6989..7df93e194 100644
--- a/pym/_emerge/depgraph.py
+++ b/pym/_emerge/depgraph.py
@@ -22,7 +22,7 @@ from portage.dbapi.dep_expand import dep_expand
 from portage.dep import Atom, best_match_to_list, extract_affecting_use, \
 	check_required_use, human_readable_required_use, match_from_list, \
 	_repo_separator
-from portage.dep._slot_abi import ignore_built_slot_abi_deps
+from portage.dep._slot_abi import ignore_built_slot_operator_deps
 from portage.eapi import eapi_has_strong_blocks, eapi_has_required_use
 from portage.exception import (InvalidAtom, InvalidDependString,
 	PackageNotFound, PortageException)
@@ -115,8 +115,8 @@ class _frozen_depgraph_config(object):
 		self._pkg_cache = {}
 		self._highest_license_masked = {}
 		dynamic_deps = myopts.get("--dynamic-deps", "y") != "n"
-		ignore_built_slot_abi_deps = myopts.get(
-			"--ignore-built-slot-abi-deps", "n") == "y"
+		ignore_built_slot_operator_deps = myopts.get(
+			"--ignore-built-slot-operator-deps", "n") == "y"
 		for myroot in trees:
 			self.trees[myroot] = {}
 			# Create a RootConfig instance that references
@@ -132,7 +132,7 @@ class _frozen_depgraph_config(object):
 					pkg_cache=self._pkg_cache,
 					pkg_root_config=self.roots[myroot],
 					dynamic_deps=dynamic_deps,
-					ignore_built_slot_abi_deps=ignore_built_slot_abi_deps)
+					ignore_built_slot_operator_deps=ignore_built_slot_operator_deps)
 			self.pkgsettings[myroot] = portage.config(
 				clone=self.trees[myroot]["vartree"].settings)
 
@@ -412,7 +412,7 @@ class _dynamic_depgraph_config(object):
 		self._needed_license_changes = backtrack_parameters.needed_license_changes
 		self._needed_use_config_changes = backtrack_parameters.needed_use_config_changes
 		self._runtime_pkg_mask = backtrack_parameters.runtime_pkg_mask
-		self._slot_abi_replace_installed = backtrack_parameters.slot_abi_replace_installed
+		self._slot_operator_replace_installed = backtrack_parameters.slot_operator_replace_installed
 		self._need_restart = False
 		# For conditions that always require user intervention, such as
 		# unsatisfied REQUIRED_USE (currently has no autounmask support).
@@ -423,7 +423,7 @@ class _dynamic_depgraph_config(object):
 		self._success_without_autounmask = False
 		self._traverse_ignored_deps = False
 		self._complete_mode = False
-		self._slot_abi_deps = {}
+		self._slot_operator_deps = {}
 
 		for myroot in depgraph._frozen_config.trees:
 			self.sets[myroot] = _depgraph_sets()
@@ -956,7 +956,7 @@ class depgraph(object):
 
 	def _slot_conflict_backtrack_abi(self, pkg, slot_nodes, conflict_atoms):
 		"""
-		If one or more conflict atoms have a SLOT/ABI dep that can be resolved
+		If one or more conflict atoms have a slot/sub-slot dep that can be resolved
 		by rebuilding the parent package, then schedule the rebuild via
 		backtracking, and return True. Otherwise, return False.
 		"""
@@ -964,7 +964,7 @@ class depgraph(object):
 		found_update = False
 		for parent_atom, conflict_pkgs in conflict_atoms.items():
 			parent, atom = parent_atom
-			if atom.slot_abi_op != "=" or not parent.built:
+			if atom.slot_operator != "=" or not parent.built:
 				continue
 
 			if pkg not in conflict_pkgs:
@@ -977,13 +977,13 @@ class depgraph(object):
 				dep = Dependency(atom=atom, child=other_pkg,
 					parent=parent, root=pkg.root)
 
-				if self._slot_abi_update_probe(dep):
-					self._slot_abi_update_backtrack(dep)
+				if self._slot_operator_update_probe(dep):
+					self._slot_operator_update_backtrack(dep)
 					found_update = True
 
 		return found_update
 
-	def _slot_abi_update_backtrack(self, dep, new_child_slot=None):
+	def _slot_operator_update_backtrack(self, dep, new_child_slot=None):
 		if new_child_slot is None:
 			child = dep.child
 		else:
@@ -1008,11 +1008,11 @@ class depgraph(object):
 		abi_masks = {}
 		if new_child_slot is None:
 			if not child.installed:
-				abi_masks.setdefault(child, {})["slot_abi_mask_built"] = None
+				abi_masks.setdefault(child, {})["slot_operator_mask_built"] = None
 		if not dep.parent.installed:
-			abi_masks.setdefault(dep.parent, {})["slot_abi_mask_built"] = None
+			abi_masks.setdefault(dep.parent, {})["slot_operator_mask_built"] = None
 		if abi_masks:
-			config.setdefault("slot_abi_mask_built", {}).update(abi_masks)
+			config.setdefault("slot_operator_mask_built", {}).update(abi_masks)
 
 		# trigger replacement of installed packages if necessary
 		abi_reinstalls = set()
@@ -1021,15 +1021,15 @@ class depgraph(object):
 		if new_child_slot is None and child.installed:
 			abi_reinstalls.add((child.root, child.slot_atom))
 		if abi_reinstalls:
-			config.setdefault("slot_abi_replace_installed",
+			config.setdefault("slot_operator_replace_installed",
 				set()).update(abi_reinstalls)
 
 		self._dynamic_config._need_restart = True
 
-	def _slot_abi_update_probe(self, dep, new_child_slot=False):
+	def _slot_operator_update_probe(self, dep, new_child_slot=False):
 		"""
-		SLOT/ABI := operators tend to prevent updates from getting pulled in,
-		since installed packages pull in packages with the SLOT/ABI that they
+		slot/sub-slot := operators tend to prevent updates from getting pulled in,
+		since installed packages pull in packages with the slot/sub-slot that they
 		were built against. Detect this case so that we can schedule rebuilds
 		and reinstalls when appropriate.
 		NOTE: This function only searches for updates that involve upgrades
@@ -1054,7 +1054,7 @@ class depgraph(object):
 			dep.parent.slot_atom):
 
 			for atom in replacement_parent.validated_atoms:
-				if not atom.slot_abi_op == "=" or \
+				if not atom.slot_operator == "=" or \
 					atom.blocker or \
 					atom.cp != dep.atom.cp:
 					continue
@@ -1074,8 +1074,8 @@ class depgraph(object):
 				for pkg in self._iter_similar_available(
 					dep.child, atom):
 					if pkg.slot == dep.child.slot and \
-						pkg.slot_abi == dep.child.slot_abi:
-						# If SLOT/ABI is identical, then there's
+						pkg.sub_slot == dep.child.sub_slot:
+						# If slot/sub-slot is identical, then there's
 						# no point in updating.
 						continue
 					if new_child_slot:
@@ -1093,7 +1093,7 @@ class depgraph(object):
 								want_downgrade = self._downgrade_probe(dep.child)
 							# be careful not to trigger a rebuild when
 							# the only version available with a
-							# different slot_abi is an older version
+							# different slot_operator is an older version
 							if not want_downgrade:
 								continue
 
@@ -1101,7 +1101,7 @@ class depgraph(object):
 						msg = []
 						msg.append("")
 						msg.append("")
-						msg.append("slot_abi_update_probe:")
+						msg.append("slot_operator_update_probe:")
 						msg.append("   existing child package:  %s" % dep.child)
 						msg.append("   existing parent package: %s" % dep.parent)
 						msg.append("   new child package:  %s" % pkg)
@@ -1116,7 +1116,7 @@ class depgraph(object):
 			msg = []
 			msg.append("")
 			msg.append("")
-			msg.append("slot_abi_update_probe:")
+			msg.append("slot_operator_update_probe:")
 			msg.append("   existing child package:  %s" % dep.child)
 			msg.append("   existing parent package: %s" % dep.parent)
 			msg.append("   new child package:  %s" % None)
@@ -1178,16 +1178,16 @@ class depgraph(object):
 					continue
 			yield pkg
 
-	def _slot_abi_trigger_reinstalls(self):
+	def _slot_operator_trigger_reinstalls(self):
 		"""
-		Search for packages with slot-abi deps on older slots, and schedule
+		Search for packages with slot-operator deps on older slots, and schedule
 		rebuilds if they can link to a newer slot that's in the graph.
 		"""
 
-		rebuild_if_new_slot_abi = self._dynamic_config.myparams.get(
-			"rebuild_if_new_slot_abi", "y") == "y"
+		rebuild_if_new_slot = self._dynamic_config.myparams.get(
+			"rebuild_if_new_slot", "y") == "y"
 
-		for slot_key, slot_info in self._dynamic_config._slot_abi_deps.items():
+		for slot_key, slot_info in self._dynamic_config._slot_operator_deps.items():
 
 			for dep in slot_info:
 				if not (dep.child.built and dep.parent and
@@ -1197,17 +1197,17 @@ class depgraph(object):
 				# Check for slot update first, since we don't want to
 				# trigger reinstall of the child package when a newer
 				# slot will be used instead.
-				if rebuild_if_new_slot_abi:
-					new_child = self._slot_abi_update_probe(dep,
+				if rebuild_if_new_slot:
+					new_child = self._slot_operator_update_probe(dep,
 						new_child_slot=True)
 					if new_child:
-						self._slot_abi_update_backtrack(dep,
+						self._slot_operator_update_backtrack(dep,
 							new_child_slot=new_child)
 						break
 
 				if dep.want_update:
-					if self._slot_abi_update_probe(dep):
-						self._slot_abi_update_backtrack(dep)
+					if self._slot_operator_update_probe(dep):
+						self._slot_operator_update_backtrack(dep)
 						break
 
 	def _reinstall_for_flags(self, pkg, forced_flags,
@@ -1614,8 +1614,8 @@ class depgraph(object):
 
 		dep.child = pkg
 		if (not pkg.onlydeps and pkg.built and
-			dep.atom and dep.atom.slot_abi_built):
-			self._add_slot_abi_dep(dep)
+			dep.atom and dep.atom.slot_operator_built):
+			self._add_slot_operator_dep(dep)
 
 		recurse = deep is True or depth + 1 <= deep
 		dep_stack = self._dynamic_config._dep_stack
@@ -1648,12 +1648,12 @@ class depgraph(object):
 			self._dynamic_config._parent_atoms[pkg] = parent_atoms
 		parent_atoms.add(parent_atom)
 
-	def _add_slot_abi_dep(self, dep):
+	def _add_slot_operator_dep(self, dep):
 		slot_key = (dep.root, dep.child.slot_atom)
-		slot_info = self._dynamic_config._slot_abi_deps.get(slot_key)
+		slot_info = self._dynamic_config._slot_operator_deps.get(slot_key)
 		if slot_info is None:
 			slot_info = []
-			self._dynamic_config._slot_abi_deps[slot_key] = slot_info
+			self._dynamic_config._slot_operator_deps[slot_key] = slot_info
 		slot_info.append(dep)
 
 	def _add_slot_conflict(self, pkg):
@@ -2106,12 +2106,12 @@ class depgraph(object):
 			# Yield ~, =*, < and <= atoms first, since those are more likely to
 			# cause slot conflicts, and we want those atoms to be displayed
 			# in the resulting slot conflict message (see bug #291142).
-			# Give similar treatment to SLOT/ABI atoms.
+			# Give similar treatment to slot/sub-slot atoms.
 			conflict_atoms = []
 			normal_atoms = []
 			abi_atoms = []
 			for atom in cp_atoms:
-				if atom.slot_abi_built:
+				if atom.slot_operator_built:
 					abi_atoms.append(atom)
 					continue
 				conflict = False
@@ -2553,8 +2553,8 @@ class depgraph(object):
 			atom_list.append((root, '__auto_rebuild__', atom))
 		for root, atom in self._rebuild.reinstall_list:
 			atom_list.append((root, '__auto_reinstall__', atom))
-		for root, atom in self._dynamic_config._slot_abi_replace_installed:
-			atom_list.append((root, '__auto_slot_abi_replace_installed__', atom))
+		for root, atom in self._dynamic_config._slot_operator_replace_installed:
+			atom_list.append((root, '__auto_slot_operator_replace_installed__', atom))
 
 		set_dict = {}
 		for root, set_name, atom in atom_list:
@@ -2708,8 +2708,8 @@ class depgraph(object):
 			return False, myfavorites
 
 		if "config" in self._dynamic_config._backtrack_infos and \
-			("slot_abi_mask_built" in self._dynamic_config._backtrack_infos["config"] or
-			"slot_abi_replace_installed" in self._dynamic_config._backtrack_infos["config"]) and \
+			("slot_operator_mask_built" in self._dynamic_config._backtrack_infos["config"] or
+			"slot_operator_replace_installed" in self._dynamic_config._backtrack_infos["config"]) and \
 			self.need_restart():
 			return False, myfavorites
 
@@ -2899,9 +2899,9 @@ class depgraph(object):
 				is_valid_flag=is_valid_flag, eapi=eapi)
 
 		if (self._dynamic_config.myparams.get(
-			"ignore_built_slot_abi_deps", "n") == "y" and
+			"ignore_built_slot_operator_deps", "n") == "y" and
 			parent and parent.built):
-			ignore_built_slot_abi_deps(depstring)
+			ignore_built_slot_operator_deps(depstring)
 
 		pkgsettings = self._frozen_config.pkgsettings[root]
 		if trees is None:
@@ -4660,9 +4660,9 @@ class depgraph(object):
 			"complete_if_new_use", "y") == "y"
 		complete_if_new_ver = self._dynamic_config.myparams.get(
 			"complete_if_new_ver", "y") == "y"
-		rebuild_if_new_slot_abi = self._dynamic_config.myparams.get(
-			"rebuild_if_new_slot_abi", "y") == "y"
-		complete_if_new_slot = rebuild_if_new_slot_abi
+		rebuild_if_new_slot = self._dynamic_config.myparams.get(
+			"rebuild_if_new_slot", "y") == "y"
+		complete_if_new_slot = rebuild_if_new_slot
 
 		if "complete" not in self._dynamic_config.myparams and \
 			(complete_if_new_use or
@@ -5346,7 +5346,7 @@ class depgraph(object):
 
 		self._process_slot_conflicts()
 
-		self._slot_abi_trigger_reinstalls()
+		self._slot_operator_trigger_reinstalls()
 
 		if not self._validate_blockers():
 			self._dynamic_config._skip_restart = True
diff --git a/pym/_emerge/main.py b/pym/_emerge/main.py
index d4b2901e3..049c3ec88 100644
--- a/pym/_emerge/main.py
+++ b/pym/_emerge/main.py
@@ -478,7 +478,7 @@ def insert_optional_args(args):
 		'--package-moves'        : y_or_n,
 		'--quiet'                : y_or_n,
 		'--quiet-build'          : y_or_n,
-		'--rebuild-if-new-slot-abi': y_or_n,
+		'--rebuild-if-new-slot': y_or_n,
 		'--rebuild-if-new-rev'   : y_or_n,
 		'--rebuild-if-new-ver'   : y_or_n,
 		'--rebuild-if-unbuilt'   : y_or_n,
@@ -754,11 +754,11 @@ def parse_opts(tmpcmdline, silent=False):
 			"choices" : true_y_or_n
 		},
 
-		"--ignore-built-slot-abi-deps": {
-			"help": "Ignore the SLOT/ABI := operator parts of dependencies that have "
+		"--ignore-built-slot-operator-deps": {
+			"help": "Ignore the slot/sub-slot := operator parts of dependencies that have "
 				"been recorded when packages where built. This option is intended "
 				"only for debugging purposes, and it only affects built packages "
-				"that specify SLOT/ABI := operator dependencies using the "
+				"that specify slot/sub-slot := operator dependencies using the "
 				"experimental \"4-slot-abi\" EAPI.",
 			"type": "choice",
 			"choices": y_or_n
@@ -877,8 +877,8 @@ def parse_opts(tmpcmdline, silent=False):
 			"choices"  : true_y_or_n,
 		},
 
-		"--rebuild-if-new-slot-abi": {
-			"help"     : ("Automatically rebuild or reinstall packages when SLOT/ABI := "
+		"--rebuild-if-new-slot": {
+			"help"     : ("Automatically rebuild or reinstall packages when slot/sub-slot := "
 				"operator dependencies can be satisfied by a newer slot, so that "
 				"older packages slots will become eligible for removal by the "
 				"--depclean action as soon as possible."),
@@ -1127,8 +1127,8 @@ def parse_opts(tmpcmdline, silent=False):
 	if myoptions.quiet_build in true_y:
 		myoptions.quiet_build = 'y'
 
-	if myoptions.rebuild_if_new_slot_abi in true_y:
-		myoptions.rebuild_if_new_slot_abi = 'y'
+	if myoptions.rebuild_if_new_slot in true_y:
+		myoptions.rebuild_if_new_slot = 'y'
 
 	if myoptions.rebuild_if_new_ver in true_y:
 		myoptions.rebuild_if_new_ver = True
diff --git a/pym/_emerge/resolver/backtracking.py b/pym/_emerge/resolver/backtracking.py
index d8f49c679..5456ea455 100644
--- a/pym/_emerge/resolver/backtracking.py
+++ b/pym/_emerge/resolver/backtracking.py
@@ -8,7 +8,7 @@ class BacktrackParameter(object):
 	__slots__ = (
 		"needed_unstable_keywords", "runtime_pkg_mask", "needed_use_config_changes", "needed_license_changes",
 		"rebuild_list", "reinstall_list", "needed_p_mask_changes",
-		"slot_abi_replace_installed"
+		"slot_operator_replace_installed"
 	)
 
 	def __init__(self):
@@ -19,7 +19,7 @@ class BacktrackParameter(object):
 		self.needed_license_changes = {}
 		self.rebuild_list = set()
 		self.reinstall_list = set()
-		self.slot_abi_replace_installed = set()
+		self.slot_operator_replace_installed = set()
 
 	def __deepcopy__(self, memo=None):
 		if memo is None:
@@ -35,7 +35,7 @@ class BacktrackParameter(object):
 		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)
-		result.slot_abi_replace_installed = copy.copy(self.slot_abi_replace_installed)
+		result.slot_operator_replace_installed = copy.copy(self.slot_operator_replace_installed)
 
 		# runtime_pkg_mask contains nested dicts that must also be copied
 		result.runtime_pkg_mask = {}
@@ -52,7 +52,7 @@ class BacktrackParameter(object):
 			self.needed_license_changes == other.needed_license_changes and \
 			self.rebuild_list == other.rebuild_list and \
 			self.reinstall_list == other.reinstall_list and \
-			self.slot_abi_replace_installed == other.slot_abi_replace_installed
+			self.slot_operator_replace_installed == other.slot_operator_replace_installed
 
 
 class _BacktrackNode(object):
@@ -125,7 +125,7 @@ class Backtracker(object):
 		for pkg, mask_info in runtime_pkg_mask.items():
 
 			if "missing dependency" in mask_info or \
-				"slot_abi_mask_built" in mask_info:
+				"slot_operator_mask_built" in mask_info:
 				continue
 
 			entry_is_valid = False
@@ -192,12 +192,12 @@ class Backtracker(object):
 					para.needed_use_config_changes[pkg] = (new_use, new_changes)
 			elif change == "slot_conflict_abi":
 				new_node.terminal = False
-			elif change == "slot_abi_mask_built":
+			elif change == "slot_operator_mask_built":
 				for pkg, mask_reasons in data.items():
 					para.runtime_pkg_mask.setdefault(pkg,
 						{}).update(mask_reasons)
-			elif change == "slot_abi_replace_installed":
-				para.slot_abi_replace_installed.update(data)
+			elif change == "slot_operator_replace_installed":
+				para.slot_operator_replace_installed.update(data)
 			elif change == "rebuild_list":
 				para.rebuild_list.update(data)
 			elif change == "reinstall_list":
diff --git a/pym/_emerge/resolver/slot_collision.py b/pym/_emerge/resolver/slot_collision.py
index 783a6483d..bc95e916e 100644
--- a/pym/_emerge/resolver/slot_collision.py
+++ b/pym/_emerge/resolver/slot_collision.py
@@ -291,8 +291,8 @@ class slot_conflict_handler(object):
 									num_all_specific_atoms += 1
 									collision_reasons[key] = atoms
 								else:
-									# The slot_abi does not match.
-									key = ("sub-slot", atom.slot_abi)
+									# The sub_slot does not match.
+									key = ("sub-slot", atom.sub_slot)
 									atoms = collision_reasons.get(key, set())
 									atoms.add((ppkg, atom, other_pkg))
 									num_all_specific_atoms += 1