Fix ChangeType UnsupportedOperationException on JS FunctionCall nodes

ChangeType.postVisit() falls through to the TypedTree branch for
JS.FunctionCall nodes, which throws UnsupportedOperationException
because withType() is not supported on MethodCall implementations.

Add a MethodCall catch-all branch before the TypedTree fallback that
uses withMethodType() instead, handling JS.FunctionCall and any other
future MethodCall implementations not explicitly handled.

Author: knutwannheden

rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java

@@ -221,6 +221,9 @@ private void addImport(JavaType.FullyQualified owningClass) {
             } else if (j instanceof J.NewClass) {
                 J.NewClass n = (J.NewClass) j;
                 j = n.withConstructorType(updateType(n.getConstructorType()));
+            } else if (j instanceof MethodCall) {
+                MethodCall call = (MethodCall) j;
+                j = (J) call.withMethodType(updateType(call.getMethodType()));
             } else if (tree instanceof TypedTree) {
                 j = ((TypedTree) tree).withType(updateType(((TypedTree) tree).getType()));
             } else if (tree instanceof JavaSourceFile) {

rewrite-javascript/src/test/java/org/openrewrite/javascript/ChangeTypeAdaptabilityTest.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openrewrite.javascript;
+
+import org.junit.jupiter.api.Test;
+import org.openrewrite.java.ChangeType;
+import org.openrewrite.javascript.tree.JS;
+import org.openrewrite.test.RewriteTest;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.openrewrite.javascript.Assertions.javascript;
+
+/**
+ * Prove that {@link ChangeType}, written for Java, does not fail on JavaScript source files
+ * containing {@link JS.FunctionCall} nodes.
+ */
+class ChangeTypeAdaptabilityTest implements RewriteTest {
+
+    @Test
+    void functionCallDoesNotThrow() {
+        AtomicBoolean hasFunctionCall = new AtomicBoolean(false);
+        rewriteRun(
+          spec -> spec.recipe(new ChangeType("Foo", "Bar", true)),
+          javascript(
+            """
+              class Foo {
+                  getHandler() {
+                      return function() { return 1; };
+                  }
+              }
+              var result = new Foo().getHandler()();
+              """,
+            """
+              class Foo {
+                  getHandler() {
+                      return function() { return 1; };
+                  }
+              }
+              var result = new Bar().getHandler()();
+              """,
+            spec -> spec.afterRecipe(cu -> {
+                new JavaScriptVisitor<Integer>() {
+                    @Override
+                    public JS.FunctionCall visitFunctionCall(JS.FunctionCall functionCall, Integer p) {
+                        hasFunctionCall.set(true);
+                        return functionCall;
+                    }
+                }.visit(cu, 0);
+                assertThat(hasFunctionCall.get())
+                  .as("Expected parsed JavaScript to contain a JS.FunctionCall node")
+                  .isTrue();
+            })
+          )
+        );
+    }
+}