Modifying code only on certain variable values.

[crankydillo]

I need to change foo(someString) to bar(someString) if someString is known to be numeric at compile time. Seems easy to do, at least in some cases, if someString comes from a literal contained within SourceFile. Even if it resolves to a constant or an enum in other files, this seems doable, but significantly more complex, via a Scanning recipe creating some kind of map of literals or something. But I'm betting this will get really complicated if there are layers of indirection spread across the entire project, e.g.

class Constants {
   public static final String NUMERIC = "123";
}

class Indirection {
   getConstant() {
      return Constants.NUMERIC;
   }
}

class Main {
    void main() {
        foo(Indirection.getConstant()); // would need to change 'foo' to 'bar' since the value is ultimately '123'
    }
}

There is nothing like evaluateIfCan(MethodInvocation) is there? Where I could do something like:

var methodInvocation = ... // represents Indirection.getConstant()
var resolvedValue = evaluateIfCAn(methodInvocation);
if (isNumeric(resolvedValue)) {
  // return changed
}
// return unchanged

If evaluateIfCan functionality exists in OpenRewrite's Java support, I'm missing it:).

Update: I created this rewrite-analysis issue.

[timtebeek]

We have something similar in rewrite-analysis, which is perhaps best illustrated with the example here:

• https://github.com/openrewrite/rewrite-feature-flags/blob/c448e2a4df5e8f42a60a172f3ebab828644609d5/src/main/java/org/openrewrite/featureflags/RemoveBooleanFlag.java#L102-L106
• https://github.com/openrewrite/rewrite-feature-flags/blob/c448e2a4df5e8f42a60a172f3ebab828644609d5/src/test/java/org/openrewrite/featureflags/RemoveBooleanFlagTest.java#L131-L177

Note that it's not an exact match with your use case, nor do I know if it'll support the get method indirection you have, but it's worth exploring for your use.

[crankydillo]

Definitely! This rewrite-analysis project might be important to folks doing complicated Java changes:)

This project contains a series of utility functions and visitors to perform complex analysis of source code.

[crankydillo]

Sorry, but going to unmark this as an answer. I need to spend more time with rewrite-analysis, but at this time guessing it's not going to give me what I ask for in the OP.

Our team will likely look into this in more depth soon, and if we can provide more info/test-cases/ideas, we'll certainly do so!

[knutwannheden]

I would like to add field initializer values to the JavaType model for static final fields where the value can be evaluated at compile time (primitive types, enums, and strings). But it will probably be a while until I get to this.

[crankydillo]

Awesome. Is there an issue for this I can watch?

[knutwannheden]

No issue at this time. If you would like to report one with your use case in it, that would already be quite helpful!

[crankydillo]

I'm kind of embarrased to ask for a feature like this:). I'm not sure if it's clear above, but I'm asking for compiler-like ability to do things like code optimization, but used for triggering rewrite changes. Is this something you envision openrewrite doing in the future?

However, I'm also interested in more simple cases, which I think you might consider. For example, we could likely cover a moderate amount of our use cases if I could change foo(Constants.NUMERIC) to bar(Constants.NUMERIC) only if the constant is a string that is numeric.

class Constants {
   public static final String NUMERIC = "123";
}
class A {
   {
      foo(Constants.NUMERIC);
   }
}

Basically, some kind of access to constants exposed in the application being rewritten. App-local constants would help, but all constants, even if in libs, would be even better. For app local constants and what I need to do above, I have the following in mind:

1. Scan app code to see if there's even any use of foo. If so, somehow record the argument used. (e.g. record use of Constants.NUMERIC)
2. Scan the code again looking for constants used in step 1. (e.g. store that Constants.NUMERIC has value '123'.)
3. Come back to files in 1 and use results from step 2 to test for numeric literals. If true, change foo to bar.

Does this make sense? When you are in any given TreeVisitor, it's not like you can get back to some kind of project wide visitor where you can do something like a 'search-for-constants', right? I had some hope that's what Tim was giving above with his example, but I don't think that's what it does.

[crankydillo]

GlobalDataFlow.Accumulator may be the 'magic sauce' I'm looking for. I've covered one use case with it. I'll let you know how that goes.

[crankydillo]

I created this rewrite-analysis issue. It does seem to have the core of what we need, but it doesn't appear to work with qualified constants or enums.

[crankydillo]

Going to close this. We very much limited our use-cases and used a hacky-ish, static variable in the recipe. @timtebeek has pointed us to a new dataflow package, and we'll look into that next time we have needs similar to this.