Fix RPC lifecycle and default export method name resolution

- Remove premature client.shutdown() in JavaToJavaScriptRpcTest that killed
  the RPC process between tests without clearing the ThreadLocal reference,
  causing 324/377 test failures. The @AfterSuite already handles cleanup.
- Fix default import method name detection in type-mapping.ts to check
  syntactic import form (isImportClause/isNamespaceImport) rather than
  relying on aliasedSymbol.name, which can be an internal name (e.g. "e"
  for express) instead of "default".
- Add null-safety fallbacks (?? emptySpace) from origin/main merge.

Author: knutwannheden

rewrite-javascript/rewrite/src/javascript/parser.ts

@@ -644,7 +644,7 @@ export class JavaScriptParserVisitor {
     private rightPadded<T extends J | boolean>(t: T, trailing: J.Space, markers?: Markers): J.RightPadded<T> {
         // For tree types (J), use intersection type: spread element and add padding
         // For primitives (boolean), use wrapper type with element property
-        const padding: J.Suffix = { after: trailing, markers: markers ?? emptyMarkers };
+        const padding: J.Suffix = { after: trailing ?? emptySpace, markers: markers ?? emptyMarkers };
         if (typeof t === 'boolean') {
             return {
                 element: t,
@@ -685,7 +685,7 @@ export class JavaScriptParserVisitor {
 
     private leftPadded<T extends J | J.Space | number | string | boolean>(before: J.Space, t: T, markers?: Markers): J.LeftPadded<T> {
         // For primitives (boolean, number, string), use wrapper type with element property
-        const padding: J.Prefix = { before: before, markers: markers ?? emptyMarkers };
+        const padding: J.Prefix = { before: before ?? emptySpace, markers: markers ?? emptyMarkers };
         if (typeof t === 'boolean' || typeof t === 'number' || typeof t === 'string') {
             return {
                 element: t,

rewrite-javascript/rewrite/src/javascript/type-mapping.ts

@@ -830,8 +830,13 @@ export class JavaScriptTypeMapping {
                             flags: 0, // TODO - determine flags
                             fullyQualifiedName: moduleSpecifier
                         } as Type.FullyQualified;
-                        // For aliased imports, use the original function name from the aliased symbol
-                        if (aliasedSymbol && aliasedSymbol.name) {
+                        // Determine the method name based on import type
+                        const isDefaultImport = exprSymbol!.declarations?.some(d =>
+                            ts.isImportClause(d) || ts.isNamespaceImport(d)
+                        );
+                        if (isDefaultImport) {
+                            methodName = '<default>';
+                        } else if (aliasedSymbol && aliasedSymbol.name) {
                             methodName = aliasedSymbol.name;
                         } else {
                             methodName = '<default>';

rewrite-javascript/rewrite/test/javascript/type-mapping.test.ts

@@ -16,7 +16,7 @@
  * limitations under the License.
  */
 import {RecipeSpec} from "../../src/test";
-import {javascript, JavaScriptVisitor, npm, packageJson, tsx, typescript} from "../../src/javascript";
+import {javascript, JavaScriptVisitor, JS, npm, packageJson, tsx, typescript} from "../../src/javascript";
 import {J, Type} from "../../src/java";
 import {ExecutionContext, foundSearchResult, Recipe} from "../../src";
 import {withDir} from "tmp-promise";
@@ -456,6 +456,53 @@ describe('JavaScript type mapping', () => {
             }, {unsafeCleanup: true});
         })
 
+        test('default export function call has <default> method name', async () => {
+            const spec = new RecipeSpec();
+            spec.recipe = markTypes((node, type) => {
+                if (Type.isMethod(type)) {
+                    const method = type as Type.Method;
+                    if (FullyQualified.getFullyQualifiedName(method.declaringType) === 'express') {
+                        return `${FullyQualified.getFullyQualifiedName(method.declaringType)} ${method.name}`;
+                    }
+                }
+                return null;
+            });
+
+            await withDir(async (repo) => {
+                await spec.rewriteRun(
+                    npm(
+                        repo.path,
+                        typescript(
+                            `
+                                import express from 'express';
+                                const app = express();
+                            `,
+                            //@formatter:off
+                            `
+                                import express from 'express';
+                                const app = /*~~(express <default>)~~>*/express();
+                            `
+                            //@formatter:on
+                        ),
+                        packageJson(
+                            `
+                              {
+                                "name": "test-project",
+                                "version": "1.0.0",
+                                "dependencies": {
+                                  "express": "^4.18.2"
+                                },
+                                "devDependencies": {
+                                  "@types/express": "^4.17.21"
+                                }
+                              }
+                            `
+                        )
+                    )
+                );
+            }, {unsafeCleanup: true});
+        });
+
         test('deprecated node methods with ES6 imports', async () => {
             const spec = new RecipeSpec();
             spec.recipe = markTypes((_, type) => {

rewrite-javascript/src/integTest/java/org/openrewrite/javascript/rpc/JavaToJavaScriptRpcTest.java

@@ -55,13 +55,9 @@ static void beforeSuite() {
                   @Override
                   public J preVisit(J tree, ExecutionContext ctx) {
                       SourceFile t = (SourceFile) modifyAll.getVisitor().visitNonNull(tree, ctx);
-                      try {
-                          assertThat(t.printAll()).isEqualTo(((SourceFile) tree).printAll());
-                          stopAfterPreVisit();
-                          return tree;
-                      } finally {
-                          client.shutdown();
-                      }
+                      assertThat(t.printAll()).isEqualTo(((SourceFile) tree).printAll());
+                      stopAfterPreVisit();
+                      return tree;
                   }
               };
           }));