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,81 @@
+/*
+ * 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.jspecify.annotations.Nullable;
+import org.junit.jupiter.api.Test;
+import org.openrewrite.ExecutionContext;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.MethodCall;
+import org.openrewrite.java.tree.TypedTree;
+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;
+
+/**
+ * Verify that a Java recipe using {@code postVisit} to update types on {@link TypedTree} nodes
+ * does not fail on JavaScript source files containing {@link JS.FunctionCall} nodes.
+ * <p>
+ * This reproduces the issue where {@link org.openrewrite.java.ChangeType} throws
+ * {@link UnsupportedOperationException} when its {@code postVisit} calls
+ * {@link TypedTree#withType} on a {@link JS.FunctionCall}, which requires
+ * {@link JS.FunctionCall#withFunctionType} instead.
+ */
+class ChangeTypeAdaptabilityTest implements RewriteTest {
+
+    @Test
+    void functionCallDoesNotThrow() {
+        AtomicBoolean hasFunctionCall = new AtomicBoolean(false);
+        rewriteRun(
+          spec -> spec.recipe(RewriteTest.toRecipe(() -> new JavaScriptVisitor<ExecutionContext>() {
+              @Override
+              public @Nullable J postVisit(J tree, ExecutionContext ctx) {
+                  J j = super.postVisit(tree, ctx);
+                  if (j instanceof JS.FunctionCall) {
+                      hasFunctionCall.set(true);
+                  }
+                  // Reproduce what ChangeType.postVisit does: specific handling for
+                  // J.MethodInvocation and J.NewClass, then MethodCall as a catch-all
+                  // for other implementations like JS.FunctionCall, and finally TypedTree
+                  if (j instanceof J.MethodInvocation) {
+                      // handled specifically by ChangeType
+                  } else if (j instanceof J.NewClass) {
+                      // handled specifically by ChangeType
+                  } else if (j instanceof MethodCall) {
+                      MethodCall call = (MethodCall) j;
+                      j = (J) call.withMethodType(call.getMethodType());
+                  } else if (j instanceof TypedTree) {
+                      j = ((TypedTree) j).withType(((TypedTree) j).getType());
+                  }
+                  return j;
+              }
+          })),
+          // getHandler()() produces a JS.FunctionCall because the callee is a call expression
+          javascript(
+            """
+              var result = getHandler()();
+              """
+          )
+        );
+        assertThat(hasFunctionCall.get())
+          .as("Expected parsed JavaScript to contain a JS.FunctionCall node")
+          .isTrue();
+    }
+}