The dependency/interface properties are translated to getDependency and
getInterface. I don't know if it is possible to fix this, but it won't matter
when the rest of the codebase is converted to Kotlin.
This is a little bit grim and probably not completely safe in all cases,
but it works well enough on the client.
Ideally I think I'd do it with a dominator tree calculated from a call
graph aware of integer constants and conditional calls, but that's quite
complicated (especially given how the existing code in the
DummyArgTransformer works).
This fixes a problem where dummy arguments that already had more than 8
possible values in their set (because the dummy argument is used in a
greater or less than condition) were not removed, as we'd replace the
IntValue with an unknown value when two branches (where the dummy
argument is not modified) are merged back together.
It should also improve performance, as we'll be doing less memory
allocation.
It is akin to SourceInterpreter, but more efficient as it only tracks
the sources of integer constants and it doesn't track sources through
copy instructions.
This is a prerequisite for removing dummy arguments - before the methods
are remapped, removing an argument might cause the method to conflict
with another method with the same name and descriptor as the replacement
descriptor.
