bugs: handle case where multiple versions of dependency are present

For `dev-dotnet/dotnet-sdk-bin` package, PDEPEND has the value of::

    ~dev-dotnet/dotnet-runtime-nugets-10.0.7
    ~dev-dotnet/dotnet-runtime-nugets-6.0.36
    ~dev-dotnet/dotnet-runtime-nugets-7.0.20
    ~dev-dotnet/dotnet-runtime-nugets-8.0.26
    ~dev-dotnet/dotnet-runtime-nugets-9.0.15

This value is grouped into a single dependency, which forces the matcher
to find a single version matching all of them (impossible). Now I added
an extra fallback to handle this case, which should be more robust and
handle cases where multiple versions of the same dependency are present.

Resolves: #221
Signed-off-by: Arthur Zamarin <arthurzam@gentoo.org>

Author: arthurzam

src/pkgdev/scripts/pkgdev_bugs.py

@@ -468,7 +468,7 @@ def _find_dependencies(self, pkg: package, keywords: set[str]):
         for res in check.feed(self.mk_fake_pkg(pkg, keywords)):
             if isinstance(res, visibility.NonsolvableDeps):
                 for dep in res.deps:
-                    dep = atom(dep).no_usedeps
+                    dep: atom = atom(dep).no_usedeps
                     issues[dep.key][res.keyword.lstrip("~")].add(dep)
 
         for pkgname, problems in issues.items():
@@ -481,13 +481,25 @@ def _find_dependencies(self, pkg: package, keywords: set[str]):
                 for keyword, deps in problems.items():
                     try:
                         match = self.find_best_match(deps, pkgset)
+                        results[match].add(keyword)
                     except (ValueError, IndexError):
-                        deps_str = " , ".join(map(str, deps))
-                        bugs.error(
-                            f"unable to find match for restrictions: {deps_str}",
-                            status=3,
-                        )
-                    results[match].add(keyword)
+                        # deps may contain contradictory version atoms (e.g. from
+                        # multiple USE-conditional targets like net8.0/net9.0/net10.0),
+                        # so try each atom individually
+                        found = False
+                        for dep in deps:
+                            try:
+                                match = self.find_best_match({dep}, pkgset)
+                                results[match].add(keyword)
+                                found = True
+                            except (ValueError, IndexError):
+                                pass
+                        if not found:
+                            deps_str = " , ".join(map(str, deps))
+                            bugs.error(
+                                f"unable to find match for restrictions: {deps_str}",
+                                status=3,
+                            )
                 yield from results.items()
 
     def load_targets(self, targets: list[tuple[str, str]]):