eclass: add ShadowedEclassPhase for multiple-eclass defined phases

[thesamesam]

Detect the basic case of an ignored eclass phase where two eclasses are
inherited, both defining the same phase, and the ebuild does not define
a custom implementation of that phase at all. This means one of the exported
phases from the eclasses is being ignored.

Ignore some eclasses with a blacklist where they are known to vary their
API by EAPI or eclass variables, at least for now, because the eclass
cache we have accessible here isn't keyed by EAPI or the context of the
sourcing ebuild.

Bug: https://bugs.gentoo.org/516014
Bug: https://bugs.gentoo.org/795006
Closes: #377
Signed-off-by: Sam James sam@gentoo.org

[thesamesam]

There's a lot of noise from things like cargo.eclass where we only use it for setting up flags but we don't want the other phases sometimes, ditto go. Not sure how to handle that (a heuristic would be fine).

One might argue this really means we should have xyz-utils.eclass more often rather than making an eclass do many things, sometimes with toggles to customise it.

We can also have this be off-by-default, but nonetheless, better heuristics would be useful..

[ferringb]

random code poking. Take what makes sense, discard what doesn't. Y'all know this code better than I do.

[ferringb]

This should be a class level frozenset, so it can be varied to test in the testcases. Plus it's more obvious.

[ferringb]

self.providers = tuple(sorted(providers)); expect the invokers of this class will forget to sort, so just force it on them. Mark providers as typing.Iterable[str]- assuming it's a string?

And yes, I'm now brutally anal about typing. The syntax sucks, but it's better devex and I'd like to eventually enforce mypy.

[ferringb]

I think this code is equivalent to above.

# use the pkg's eapi, not latest.  Conflicts in EAPI's the pkg isn't, don't matter for it until it is that EAPI/
possible_conflicts = set(pkg.eapi.phases_rev)
# strip out what the pkg defines
for node in bash.func_query.captures(pkg.tree.root_node).get("func", ()):
    func_name = pkg.node_str(node.child_by_field_name("name"))
    possible_conflicts.discard(func_name)

for phase in possible_conflicts:
  # iterate the remaining phases, finding where there are multiple eclasses providing this phase.
  eclass_sources = []
  for eclasses, _ in inherits:
    for eclass in eclasses:
      # I assume .functions supports __contains__, and isn't strictly typing.Iterable[str]
      if f'{eclass}_phase' in eclass.functions:
        eclass_sources.append(eclass)
  if len(eclass_sources) > 1:
    yield ShadowedEclassPhase(phase, eclass_sources, pkg=pkg)

I'd also rename providers to eclasses in ShadowedEclassPhase to be clearer.

[thesamesam]

We should also filter out eclasses where of those defining the phase, they have @PROVIDES which has the phase (because it might wrap the eclass and call that phase for you).