Using ChangeType with non-existing oldFullyQualifiedTypeName class

[zepfred]

Hey,

I'm facing a situation where I need to replace a class that was already removed with a new one, but the built-in ChangeType recipe is not working. This might be expected behavior, but I want to confirm if the following example is doable.

class RecipeTest implements RewriteTest {

    @Override
    public void defaults(RecipeSpec spec) {
        spec.recipes(new FindMissingTypes(false), new ChangeType(
                "com.old.OldType", "com.new.NewType", false));
    }

    @Test
    void testTypeChangeInClass() {
        rewriteRun(
                java("""
                        package com.example;
                        import com.old.OldType;

                        public class TestClass {
                            OldType field;
                        }
                        """,
                        """
                                package com.example;
                                import com.new.NewType;

                                public class TestClass {
                                    NewType field;
                                }
                                """));
    }
}

I'm getting the following:

16:34:48.020 [l-1-worker-1] WARN  com/example/TestClass.java:2: error: package com.old does not exist
16:34:48.021 [l-1-worker-1] WARN  import com.old.OldType;
16:34:48.021 [l-1-worker-1] WARN                ^
16:34:48.021 [l-1-worker-1] WARN  com/example/TestClass.java:5: error: cannot find symbol
16:34:48.021 [l-1-worker-1] WARN      OldType field;
16:34:48.021 [l-1-worker-1] WARN      ^
16:34:48.021 [l-1-worker-1] WARN    symbol:   class OldType
16:34:48.021 [l-1-worker-1] WARN    location: class TestClass

java.lang.IllegalStateException: LST contains missing or invalid type information
Identifier->VariableDeclarations->Block->ClassDeclaration->CompilationUnit
/*~~(Identifier type is missing or malformed)~~>*/OldType

I understand that OldType does not exist, and that's my current use case. Applying typeValidationOptions (TypeValidation.none()); allows it to run, but no changes are applied.

Is this intended behavior? Is there any setting I could apply to use ChangeType?

[timtebeek]

hi! We need type information to be able to make code changes; in your test you do not provide the type on the classpath, either through .dependsOn, .classpath or .classpathFromResources; that means the type will be missing, and why you need .typeValidationOptions to run.

For your recipe consumers, do you expect the type to be missing there too (e.g. the project does not compile)? Or is it still present on the version they are using? I suspect the latter, so then your test can be made to run through any of the three methods named above. Let me know if that's not clear, or not what you had intended!

[zepfred]

Hey,

For your recipe consumers, do you expect the type to be missing there too (e.g. the project does not compile)?

Yes, I expect it will be missing. The type I want to replace has been removed, and the project does not compile.

In that case, the type is not present in the classpath. Is it still possible to use the recipe ChangeType?

[zepfred]

@timtebeek, thanks for the answer. It helped me figure out a way to do that. You're right. I can use dependsOn and add a stub to the JavaTemplate.

[timtebeek]

Glad to hear that worked! All the best there.

[zepfred]

For visibility, here's the solution using dependsOn:

class RecipeTest implements RewriteTest {

    @Override
    public void defaults(RecipeSpec spec) {
        spec
                .parser(JavaParser.fromJavaVersion()
                        .dependsOn("package com.old; public class OldType {}"))
                .recipes(new FindMissingTypes(false),
                        new ChangeType("com.old.OldType", "com.new.NewType", false))
                .typeValidationOptions(TypeValidation.builder().allowMissingType(ignore -> true).build());
    }

    @Test
    void testTypeChangeInClass() {
        rewriteRun(
                java("""
                        package com.example;

                        import com.old.OldType;

                        public class TestClass {
                            OldType field;
                        }
                        """,
                        """
                                package com.example;

                                import com.new.NewType;

                                public class TestClass {
                                    NewType field;
                                }
                                """));
    }
}