tatt: add --enable-prefixes and --disable-prefixes

Two USE flag prefix options, matched the same way as --ignore-prefixes:
--enable-prefixes flags are always on, --disable-prefixes flags always off,
in every combination and in every mode. They feed force_true/force_false, so
the constraint solver never proposes them and the randomized modes never draw
them, rather than merely biasing a preference the way --ignore-prefixes does.

The profile keeps the last word. A flag it forces on cannot be disabled and
one it masks cannot be enabled; either is kept as the profile has it and
warned about, since portage would ignore the request anyway. "test" is left
to --test alone. A flag matched by both options is contradictory and errors
out, as does a package whose REQUIRED_USE admits no combination once the
options are applied, previously such a package was dropped from the job
script without a word.

Relates: #164
Relates: #149 (comment)
Signed-off-by: Arthur Zamarin <arthurzam@gentoo.org>

Author: arthurzam

NEWS.rst

@@ -39,6 +39,13 @@ pkgdev 0.2.17 (unreleased)
 - tatt: fix ebuild ``IUSE`` defaults overriding the profile when deciding a
   package's default USE configuration (Arthur Zamarin, #183)
 
+- tatt: add ``--enable-prefixes`` and ``--disable-prefixes``, USE flag prefixes
+  which are always resp. never enabled, in every combination and every mode.
+  The profile has the last word: flags it forces on cannot be disabled and
+  flags it masks cannot be enabled, both kept as the profile has them with a
+  warning. A package whose ``REQUIRED_USE`` admits no combination once the
+  options are applied raises an error (Arthur Zamarin, #164)
+
 pkgdev 0.2.16 (2026-07-31)
 --------------------------
 

data/share/bash-completion/completions/pkgdev

@@ -230,6 +230,8 @@ _pkgdev() {
                 -t --test
                 -u --use-combos
                 --ignore-prefixes
+                --enable-prefixes
+                --disable-prefixes
                 --use-default
                 --use-random
                 --use-expand-random

data/share/zsh/site-functions/_pkgdev

@@ -110,6 +110,8 @@ case $state in
           {'(--test)-t','(-t)--test'}'[run test phase for the packages]' \
           {'(--use-combos)-u','(-u)--use-combos'}'[maximal number USE combinations to be tested]:number' \
           '--ignore-prefixes[USE flags prefixes that won'\''t be randomized]:prefixes' \
+          '--enable-prefixes[USE flags prefixes that will always be enabled]:prefixes' \
+          '--disable-prefixes[USE flags prefixes that will never be enabled]:prefixes' \
           '(--use-random --use-expand-random)--use-default[prefer to use default use flags configuration]' \
           '(--use-default --use-expand-random)--use-random[turn on random use flags, with default USE_EXPAND]' \
           '(--use-default --use-random)--use-expand-random[turn on random use flags, including USE_EXPAND]' \

src/pkgdev/scripts/pkgdev_tatt.py

@@ -7,13 +7,16 @@
 from importlib.resources import read_text
 from itertools import islice
 from pathlib import Path
+from typing import NamedTuple
 
 from pkgcore.bugzilla.apikey import BugzillaApiKey
 from pkgcore.restrictions import boolean, packages, values
 from pkgcore.restrictions.required_use import find_constraint_satisfaction, iter_flags
 from pkgcore.util import commandline
 from pkgcore.util import packages as pkgutils
 from snakeoil.cli import arghparse
+from snakeoil.cli.exceptions import UserException
+from snakeoil.strings import pluralism
 
 from ..cli import ArgumentParser
 
@@ -70,6 +73,36 @@
         still be changed from defaults.
     """,
 )
+use_opts.add_argument(
+    "--enable-prefixes",
+    default=[],
+    action=arghparse.CommaSeparatedValuesAppend,
+    help="USE flags prefixes that will always be enabled",
+    docs="""
+        Comma separated USE flags prefixes which are always enabled, in every
+        USE combination and in every mode.
+
+        Flags the profile masks cannot be enabled, and are kept disabled with
+        a warning. ``test`` is never affected, use ``--test`` for it.
+    """,
+)
+use_opts.add_argument(
+    "--disable-prefixes",
+    default=[],
+    action=arghparse.CommaSeparatedValuesAppend,
+    help="USE flags prefixes that will never be enabled",
+    docs="""
+        Comma separated USE flags prefixes which are never enabled, in every
+        USE combination and in every mode. This is useful for expensive or
+        known broken USE flags such as ``lto`` and ``pgo``.
+
+        Flags the profile forces on cannot be disabled, and are kept enabled
+        with a warning. ``test`` is never affected, use ``--test`` for it.
+
+        If ``REQUIRED_USE`` admits no combination once these options are
+        applied, the package cannot be tested and an error is raised.
+    """,
+)
 random_use_opts = use_opts.add_mutually_exclusive_group()
 random_use_opts.add_argument(
     "--use-default",
@@ -278,13 +311,57 @@ def _groupby_use_expand(
     return use_flags, use_expand_dict
 
 
-def _build_job(namespace, pkg, is_test: bool):
-    use_expand_prefixes = tuple(s.lower() + "_" for s in namespace.domain.profile.use_expand)
-    immutable, enabled, _disabled = namespace.domain.get_package_use_unconfigured(pkg)
+class UnsatisfiableUse(UserException):
+    """No USE combination is testable for a package."""
 
+
+class _PkgUse(NamedTuple):
+    """USE flag state of a package, shared by all of its jobs."""
+
+    immutable: frozenset[str]
+    enabled: frozenset[str]
+    iuse: frozenset[str]
+    force_on: frozenset[str]
+    force_off: frozenset[str]
+
+
+def _resolve_use(namespace, pkg, err):
+    """Determine a package's USE flag state, honoring the prefix options."""
+    immutable, enabled, masked = namespace.domain.get_package_use_unconfigured(pkg)
     iuse = frozenset(pkg.iuse_stripped)
-    force_true = immutable.union(("test",) if is_test else ())
-    force_false = ("test",) if not is_test else ()
+
+    def matching(prefixes):
+        # "test" is driven by --test alone, never by the prefix options
+        return frozenset(use for use in iuse if use.startswith(tuple(prefixes))) - {"test"}
+
+    force_on, force_off = matching(namespace.enable_prefixes), matching(namespace.disable_prefixes)
+    if both := force_on.intersection(force_off):
+        raise UnsatisfiableUse(
+            f"{pkg.cpvstr}: USE flag{pluralism(both)} matched by both --enable-prefixes "
+            f"and --disable-prefixes: {', '.join(sorted(both))}"
+        )
+
+    # the profile has the last word, its forced and masked flags can't be flipped
+    for option, state, flags, profile_flags in (
+        ("--disable-prefixes", "forced", force_off, immutable),
+        ("--enable-prefixes", "masked", force_on, masked),
+    ):
+        if conflict := flags.intersection(profile_flags):
+            err.warn(
+                f"{pkg.cpvstr}: ignoring {option} for profile {state} USE "
+                f"flag{pluralism(conflict)}: {', '.join(sorted(conflict))}"
+            )
+    return _PkgUse(
+        immutable, enabled, iuse, force_on.difference(masked), force_off.difference(immutable)
+    )
+
+
+def _build_job(namespace, pkg, pkg_use: _PkgUse, is_test: bool):
+    use_expand_prefixes = tuple(s.lower() + "_" for s in namespace.domain.profile.use_expand)
+    immutable, enabled, iuse = pkg_use.immutable, pkg_use.enabled, pkg_use.iuse
+
+    force_true = immutable.union(pkg_use.force_on, ("test",) if is_test else ())
+    force_false = pkg_use.force_off.union(("test",) if not is_test else ())
 
     if namespace.random_use == "d":
         prefer_true = enabled
@@ -348,19 +425,27 @@ def resolve_unconstrained():
             produced += 1
             if produced >= wanted:
                 return
+        if not produced:
+            forced = sorted(pkg_use.force_on) + [f"-{use}" for use in sorted(pkg_use.force_off)]
+            raise UnsatisfiableUse(
+                f"{pkg.cpvstr}: no USE combination satisfies REQUIRED_USE"
+                + (f" with {', '.join(forced)}" if forced else "")
+            )
         # replay the combinations if REQUIRED_USE admits fewer than asked for,
         # redrawing the unconstrained flags each pass
         if exhausted or not randomize:
             return
 
 
-def _build_jobs(namespace, pkgs):
+def _build_jobs(namespace, pkgs, err):
     for pkg in pkgs:
-        for flags in islice(_build_job(namespace, pkg, False), namespace.use_combos):
+        pkg_use = _resolve_use(namespace, pkg, err)
+        for flags in islice(_build_job(namespace, pkg, pkg_use, False), namespace.use_combos):
             yield pkg.versioned_atom, False, flags
 
         if namespace.test:
-            yield pkg.versioned_atom, True, next(iter(_build_job(namespace, pkg, True)))
+            flags = next(iter(_build_job(namespace, pkg, pkg_use, True)))
+            yield pkg.versioned_atom, True, flags
 
 
 def _create_config_dir(directory: Path):
@@ -430,7 +515,7 @@ def main(options, out, err):
     from jinja2 import Template
 
     script = Template(template, trim_blocks=True, lstrip_blocks=True).render(
-        jobs=list(_build_jobs(options, pkgs)),
+        jobs=list(_build_jobs(options, pkgs, err)),
         report_file=job_name + ".report",
         job_name=job_name,
         log_dir=options.logs_dir,