@openrewrite/rewrite 8.62.2 → 8.62.4

package/src/javascript/type-mapping.ts

@@ -34,8 +34,7 @@ export class JavaScriptTypeMapping {
     private readonly regExpSymbol: ts.Symbol | undefined;
 
     constructor(
-        private readonly checker: ts.TypeChecker,
-        private readonly projectRoot: string = process.cwd()
+        private readonly checker: ts.TypeChecker
     ) {
         this.regExpSymbol = checker.resolveName(
             "RegExp",
@@ -62,15 +61,8 @@ export class JavaScriptTypeMapping {
             return existing;
         }
 
-        // Check if this is an array type BEFORE checking for classes
-        // TypeScript represents Array<T> as a reference to the Array interface
-        if (this.checker.isArrayType(type)) {
-            const arrayType = this.createArrayType(type as ts.TypeReference);
-            this.typeCache.set(signature, arrayType);
-            return arrayType;
-        }
-
-        // Check for class/interface/enum types (but not arrays)
+        // Check for class/interface/enum types (including arrays)
+        // Arrays in JavaScript are objects with methods, so we treat them as class types
         const symbol = type.getSymbol?.();
         if (symbol) {
             if (symbol.flags & (ts.SymbolFlags.Class | ts.SymbolFlags.Interface | ts.SymbolFlags.Enum | ts.SymbolFlags.TypeAlias)) {
@@ -169,41 +161,164 @@ export class JavaScriptTypeMapping {
             // Get the method name
             if (ts.isPropertyAccessExpression(node.expression)) {
                 methodName = node.expression.name.getText();
+
+                // Check if the object is an imported symbol
+                const objSymbol = this.checker.getSymbolAtLocation(node.expression.expression);
+                let isImport = false;
+                if (objSymbol) {
+                    // Only call getAliasedSymbol if the symbol is actually an alias
+                    if (objSymbol.flags & ts.SymbolFlags.Alias) {
+                        const aliasedSymbol = this.checker.getAliasedSymbol(objSymbol);
+                        isImport = aliasedSymbol && aliasedSymbol !== objSymbol;
+                    }
+                }
+
                 const exprType = this.checker.getTypeAtLocation(node.expression.expression);
-                declaringType = this.getType(exprType) as Type.FullyQualified;
+                const mappedType = this.getType(exprType);
+
+                // Handle different types
+                if (mappedType && mappedType.kind === Type.Kind.Class) {
+                    // Update the declaring type with the corrected FQN
+                    if (isImport && objSymbol) {
+                        const importName = objSymbol.getName();
+                        const origFqn = (mappedType as Type.Class).fullyQualifiedName;
+                        const lastDot = origFqn.lastIndexOf('.');
+                        if (lastDot > 0) {
+                            const typeName = origFqn.substring(lastDot + 1);
+                            declaringType = {
+                                kind: Type.Kind.Class,
+                                fullyQualifiedName: `${importName}.${typeName}`
+                            } as Type.FullyQualified;
+                        } else {
+                            declaringType = mappedType as Type.FullyQualified;
+                        }
+                    } else {
+                        declaringType = mappedType as Type.FullyQualified;
+                    }
+                } else {
+                    // Handle primitive types and other non-class types
+                    if (mappedType) {
+                        if ((mappedType as any).keyword === 'String') {
+                            declaringType = {
+                                kind: Type.Kind.Class,
+                                fullyQualifiedName: 'lib.String'
+                            } as Type.FullyQualified;
+                        } else if ((mappedType as any).keyword === 'Number') {
+                            declaringType = {
+                                kind: Type.Kind.Class,
+                                fullyQualifiedName: 'lib.Number'
+                            } as Type.FullyQualified;
+                        } else {
+                            // Fallback for other types
+                            declaringType = mappedType as Type.FullyQualified;
+                        }
+                    } else {
+                        // Default to unknown if we can't determine the type
+                        declaringType = Type.unknownType as Type.FullyQualified;
+                    }
+                }
+
+                // For string methods like 'hello'.split(), ensure we have a proper declaring type for primitives
+                if (!isImport && declaringType === Type.unknownType) {
+                    // If the expression type is a primitive string, use lib.String as declaring type
+                    const typeString = this.checker.typeToString(exprType);
+                    if (typeString === 'string' || exprType.flags & ts.TypeFlags.String || exprType.flags & ts.TypeFlags.StringLiteral) {
+                        declaringType = {
+                            kind: Type.Kind.Class,
+                            fullyQualifiedName: 'lib.String'
+                        } as Type.FullyQualified;
+                    } else if (typeString === 'number' || exprType.flags & ts.TypeFlags.Number || exprType.flags & ts.TypeFlags.NumberLiteral) {
+                        declaringType = {
+                            kind: Type.Kind.Class,
+                            fullyQualifiedName: 'lib.Number'
+                        } as Type.FullyQualified;
+                    } else {
+                        // Fallback for other primitive types or unknown
+                        declaringType = Type.unknownType as Type.FullyQualified;
+                    }
+                }
+
             } else if (ts.isIdentifier(node.expression)) {
                 methodName = node.expression.getText();
-                // For standalone functions, we need to determine the appropriate declaring type
-                const exprType = this.checker.getTypeAtLocation(node.expression);
-                const funcType = this.getType(exprType);
-
-                if (funcType && funcType.kind === Type.Kind.Class) {
-                    const fqn = (funcType as Type.Class).fullyQualifiedName;
-                    const lastDot = fqn.lastIndexOf('.');
-
-                    if (lastDot > 0) {
-                        // For functions from modules, use the module part as declaring type
-                        // Examples:
-                        // - "node.assert" -> declaring type: "node"
-                        // - "@types/lodash.map" -> declaring type: "@types/lodash"
-                        // - "@types/express.express" -> declaring type: "@types/express"
+
+                // Check if this is an import first
+                const symbol = this.checker.getSymbolAtLocation(node.expression);
+                let moduleSpecifier: string | undefined;
+
+                if (symbol) {
+                    // Check if this is an aliased symbol (i.e., an import)
+                    let aliasedSymbol: ts.Symbol | undefined;
+                    if (symbol.flags & ts.SymbolFlags.Alias) {
+                        aliasedSymbol = this.checker.getAliasedSymbol(symbol);
+                    }
+
+                    // If getAliasedSymbol returns something different, it's an import
+                    if (aliasedSymbol && aliasedSymbol !== symbol) {
+                        // This is definitely an imported symbol
+                        // Now find the import declaration to get the module specifier
+                        if (symbol.declarations && symbol.declarations.length > 0) {
+                            let importNode: ts.Node = symbol.declarations[0];
+
+                            // Traverse up to find the ImportDeclaration
+                            while (importNode && !ts.isImportDeclaration(importNode)) {
+                                importNode = importNode.parent;
+                            }
+
+                            if (importNode && ts.isImportDeclaration(importNode)) {
+                                const importDeclNode = importNode as ts.ImportDeclaration;
+                                if (ts.isStringLiteral(importDeclNode.moduleSpecifier)) {
+                                    moduleSpecifier = importDeclNode.moduleSpecifier.text;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if (moduleSpecifier) {
+                    // This is an imported function - use the module specifier as declaring type
+                    if (moduleSpecifier.startsWith('node:')) {
+                        // Node.js built-in module
                         declaringType = {
                             kind: Type.Kind.Class,
-                            fullyQualifiedName: fqn.substring(0, lastDot)
+                            fullyQualifiedName: 'node'
                         } as Type.FullyQualified;
+                        methodName = moduleSpecifier.substring(5); // Remove 'node:' prefix
                     } else {
-                        // No dots in the name - the type IS the module itself
-                        // This handles single-name modules like "axios", "lodash" etc.
-                        declaringType = funcType as Type.FullyQualified;
+                        // Regular module import
+                        declaringType = {
+                            kind: Type.Kind.Class,
+                            fullyQualifiedName: moduleSpecifier
+                        } as Type.FullyQualified;
+                        methodName = '<default>';
                     }
                 } else {
-                    // Try to use the symbol's parent or module
-                    const parent = (symbol as any).parent;
-                    if (parent) {
-                        const parentType = this.checker.getDeclaredTypeOfSymbol(parent);
-                        declaringType = this.getType(parentType) as Type.FullyQualified;
+                    // Fall back to the original logic for non-imported functions
+                    const exprType = this.checker.getTypeAtLocation(node.expression);
+                    const funcType = this.getType(exprType);
+
+                    if (funcType && funcType.kind === Type.Kind.Class) {
+                        const fqn = (funcType as Type.Class).fullyQualifiedName;
+                        const lastDot = fqn.lastIndexOf('.');
+
+                        if (lastDot > 0) {
+                            // For functions from modules, use the module part as declaring type
+                            declaringType = {
+                                kind: Type.Kind.Class,
+                                fullyQualifiedName: fqn.substring(0, lastDot)
+                            } as Type.FullyQualified;
+                        } else {
+                            // No dots in the name - the type IS the module itself
+                            declaringType = funcType as Type.FullyQualified;
+                        }
                     } else {
-                        declaringType = Type.unknownType as Type.FullyQualified;
+                        // Try to use the symbol's parent or module
+                        const parent = (symbol as any).parent;
+                        if (parent) {
+                            const parentType = this.checker.getDeclaredTypeOfSymbol(parent);
+                            declaringType = this.getType(parentType) as Type.FullyQualified;
+                        } else {
+                            declaringType = Type.unknownType as Type.FullyQualified;
+                        }
                     }
                 }
             } else {
@@ -298,27 +413,12 @@ export class JavaScriptTypeMapping {
         }) as Type.Method;
     }
 
-    /**
-     * Create a JavaType.Array from a TypeScript array type
-     */
-    private createArrayType(type: ts.TypeReference): Type.Array {
-        // Get the element type (type argument of Array<T>)
-        const typeArgs = this.checker.getTypeArguments(type);
-        const elemType = typeArgs.length > 0 ? this.getType(typeArgs[0]) : Type.unknownType;
-        
-        return Object.assign(new NonDraftableType(), {
-            kind: Type.Kind.Array,
-            elemType: elemType,
-            annotations: [],
-            toJSON: function () {
-                return Type.signature(this);
-            }
-        }) as Type.Array;
-    }
 
     /**
      * Get the fully qualified name for a TypeScript type.
-     * Format: "module-specifier.TypeName" (e.g., "@mui/material.Button", "src/components/Button.Button")
+     * Uses TypeScript's built-in resolution which properly handles things like:
+     * - React.Component (not @types/react.Component)
+     * - _.LoDashStatic (not @types/lodash.LoDashStatic)
      */
     private getFullyQualifiedName(type: ts.Type): string {
         const symbol = type.getSymbol?.();
@@ -326,140 +426,105 @@ export class JavaScriptTypeMapping {
             return "unknown";
         }
 
-        const typeName = symbol.getName();
-        const declaration = symbol.valueDeclaration || symbol.declarations?.[0];
-        if (!declaration) {
-            // No declaration - might be a built-in or synthetic type
-            if (builtInTypes.has(typeName)) {
-                return `lib.${typeName}`;
-            }
-            return typeName;
-        }
-
-        const sourceFile = declaration.getSourceFile();
-        const fileName = sourceFile.fileName;
-
-        // Check if this is a test file (snowflake ID as filename)
-        // Test files are generated with numeric IDs like "672087069480189952.ts"
-        if (/^\d+\.(ts|tsx|js|jsx)$/.test(fileName)) {
-            // For test files, just return the type name without module prefix
-            return typeName;
-        }
-
-        // Check if this is from TypeScript's lib files (lib.d.ts, lib.dom.d.ts, etc.)
-        if (fileName.includes("/typescript/lib/lib.") || fileName.includes("\\typescript\\lib\\lib.")) {
-            return `lib.${typeName}`;
-        }
+        // First, check if this symbol is an import/alias
+        // For imported types, we want to use the module specifier instead of the file path
+        if (symbol.flags & ts.SymbolFlags.Alias) {
+            const aliasedSymbol = this.checker.getAliasedSymbol(symbol);
+            if (aliasedSymbol && aliasedSymbol !== symbol && symbol.declarations && symbol.declarations.length > 0) {
+                // Try to find the import declaration to get the module specifier
+                let importNode: ts.Node | undefined = symbol.declarations[0];
+
+                // Traverse up to find the ImportDeclaration or ImportSpecifier
+                while (importNode && importNode.parent && !ts.isImportDeclaration(importNode) && !ts.isImportSpecifier(importNode)) {
+                    importNode = importNode.parent;
+                }
 
-        // Check if this is from an external module (node_modules or .d.ts)
-        if (sourceFile.isDeclarationFile || fileName.includes("node_modules")) {
-            const packageName = this.extractPackageName(fileName);
-            if (packageName) {
-                // Special handling for @types/node - these are Node.js built-in modules
-                // and should be mapped to "node.*" instead of "@types/node.*"
-                if (packageName === "@types/node") {
-                    // Extract the module name from the file path
-                    // e.g., /node_modules/@types/node/assert.d.ts -> assert
-                    // e.g., /node_modules/@types/node/fs/promises.d.ts -> fs/promises
-                    const nodeMatch = fileName.match(/node_modules\/@types\/node\/([^.]+)\.d\.ts/);
-                    if (nodeMatch) {
-                        const modulePath = nodeMatch[1];
-                        // For default exports from Node modules, we want the module to be the "class"
-                        // But we still need to include the type name for proper identification
-                        if (typeName === "default" || typeName === modulePath) {
-                            // This is likely the default export, just use the module name
-                            return `node.${modulePath}`;
+                let moduleSpecifier: string | undefined;
+
+                if (importNode && ts.isImportSpecifier(importNode)) {
+                    // Named import like: import { ClipLoader } from 'react-spinners'
+                    // ImportSpecifier -> NamedImports -> ImportClause -> ImportDeclaration
+                    const namedImports = importNode.parent; // NamedImports
+                    if (namedImports && ts.isNamedImports(namedImports)) {
+                        const importClause = namedImports.parent; // ImportClause
+                        if (importClause && ts.isImportClause(importClause)) {
+                            const importDecl = importClause.parent; // ImportDeclaration
+                            if (importDecl && ts.isImportDeclaration(importDecl) && ts.isStringLiteral(importDecl.moduleSpecifier)) {
+                                moduleSpecifier = importDecl.moduleSpecifier.text;
+                            }
                         }
-                        // For named exports, include both module and type name
-                        if (modulePath.includes('/')) {
-                            return `node.${modulePath.replace(/\//g, '.')}.${typeName}`;
-                        }
-                        return `node.${modulePath}.${typeName}`;
                     }
-                    // Fallback for @types/node types that don't match the pattern
-                    return `node.${typeName}`;
+                } else if (importNode && ts.isImportDeclaration(importNode)) {
+                    // Default or namespace import
+                    if (ts.isStringLiteral(importNode.moduleSpecifier)) {
+                        moduleSpecifier = importNode.moduleSpecifier.text;
+                    }
+                }
+
+                if (moduleSpecifier) {
+                    // Build the fully qualified name from module specifier + symbol name
+                    const symbolName = symbol.getName();
+                    return `${moduleSpecifier}.${symbolName}`;
                 }
-                return `${packageName}.${typeName}`;
             }
         }
 
-        // For local files, use relative path from project root
-        const relativePath = this.getRelativeModulePath(fileName);
-        return `${relativePath}.${typeName}`;
-    }
-
-    /**
-     * Extract package name from a node_modules path.
-     * Examples:
-     * - /path/to/project/node_modules/react/index.d.ts -> "react"
-     * - /path/to/project/node_modules/@mui/material/Button/index.d.ts -> "@mui/material"
-     */
-    private extractPackageName(fileName: string): string | null {
-        const match = fileName.match(/node_modules\/(@[^\/]+\/[^\/]+|[^\/]+)/);
-        return match ? match[1] : null;
-    }
+        // Fall back to TypeScript's built-in getFullyQualifiedName
+        // This returns names with quotes that we need to clean up
+        // e.g., '"React"."Component"' -> 'React.Component'
+        const tsQualifiedName = this.checker.getFullyQualifiedName(symbol);
+        let cleanedName = tsQualifiedName.replace(/"/g, '');
+
+        // Check if this is a file path from node_modules (happens with some packages)
+        // TypeScript sometimes returns full paths instead of module names
+        if (cleanedName.includes('node_modules/')) {
+            // Extract the module name from the path
+            // Example: /private/var/.../node_modules/react-spinners/src/index.ClipLoader
+            // Should become: react-spinners.ClipLoader
+            const nodeModulesIndex = cleanedName.indexOf('node_modules/');
+            const afterNodeModules = cleanedName.substring(nodeModulesIndex + 'node_modules/'.length);
+
+            // Split by '/' to get parts of the path
+            const pathParts = afterNodeModules.split('/');
+
+            if (pathParts.length > 0) {
+                // First part is the package name (might be scoped like @types)
+                let packageName = pathParts[0];
+
+                // Handle scoped packages
+                if (packageName.startsWith('@') && pathParts.length > 1) {
+                    packageName = `${packageName}/${pathParts[1]}`;
+                }
 
-    /**
-     * Get relative module path from project root.
-     * Removes file extension and uses forward slashes.
-     */
-    private getRelativeModulePath(fileName: string): string {
-        // Remove project root and normalize path
-        let relativePath = fileName;
-        if (fileName.startsWith(this.projectRoot)) {
-            relativePath = fileName.slice(this.projectRoot.length);
+                // Find the symbol name (everything after the last dot in the original cleaned name)
+                const lastDotIndex = cleanedName.lastIndexOf('.');
+                if (lastDotIndex > 0) {
+                    const symbolName = cleanedName.substring(lastDotIndex + 1);
+                    cleanedName = `${packageName}.${symbolName}`;
+                } else {
+                    cleanedName = packageName;
+                }
+            }
         }
 
-        // Remove leading slash and file extension
-        relativePath = relativePath.replace(/^\//, '').replace(/\.[^/.]+$/, '');
-
-        // Convert backslashes to forward slashes (for Windows)
-        relativePath = relativePath.replace(/\\/g, '/');
+        // If it's just a simple name without dots, check if it's a built-in type
+        if (!cleanedName.includes('.')) {
+            if (builtInTypes.has(cleanedName)) {
+                return `lib.${cleanedName}`;
+            }
+        }
 
-        return relativePath;
+        return cleanedName;
     }
 
+
     /**
      * Create an empty JavaType.Class shell from a TypeScript type.
      * The shell will be populated later to handle circular references.
      */
     private createEmptyClassType(type: ts.Type): Type.Class {
-        // Use our custom getFullyQualifiedName method for consistent naming
-        let fullyQualifiedName = this.getFullyQualifiedName(type);
-
-        // If getFullyQualifiedName returned unknown, fall back to TypeScript's method
-        if (fullyQualifiedName === "unknown") {
-            const symbol = type.symbol;
-            fullyQualifiedName = symbol ? this.checker.getFullyQualifiedName(symbol) : `<anonymous>${this.checker.typeToString(type)}`;
-
-            // Fix FQN for types from @types packages
-            // TypeScript returns "_.LoDashStatic" but we want "@types/lodash.LoDashStatic"
-            if (symbol && symbol.declarations && symbol.declarations.length > 0) {
-                const sourceFile = symbol.declarations[0].getSourceFile();
-                const fileName = sourceFile.fileName;
-                // Check if this is from @types package
-                const typesMatch = fileName.match(/node_modules\/@types\/([^/]+)/);
-                if (typesMatch) {
-                    const packageName = typesMatch[1];
-                    // Special handling for @types/node - use "node" prefix instead
-                    if (packageName === "node") {
-                        // Extract the module name from the file path if possible
-                        const nodeMatch = fileName.match(/node_modules\/@types\/node\/([^.]+)\.d\.ts/);
-                        if (nodeMatch) {
-                            const modulePath = nodeMatch[1];
-                            // Replace the module specifier with node.module
-                            fullyQualifiedName = fullyQualifiedName.replace(/^[^.]+\./, `node.${modulePath}.`);
-                        } else {
-                            // Fallback: just use "node" prefix
-                            fullyQualifiedName = fullyQualifiedName.replace(/^[^.]+\./, `node.`);
-                        }
-                    } else {
-                        // Replace the module specifier part with @types/package
-                        fullyQualifiedName = fullyQualifiedName.replace(/^[^.]+\./, `@types/${packageName}.`);
-                    }
-                }
-            }
-        }
+        // Use our getFullyQualifiedName method which uses TypeScript's built-in resolution
+        const fullyQualifiedName = this.getFullyQualifiedName(type);
 
         // Determine the class kind based on symbol flags
         let classKind = Type.Class.Kind.Interface; // Default to interface

package/src/javascript/visitor.ts

@@ -40,7 +40,7 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
     }
 
     // noinspection JSUnusedLocalSymbols
-    protected override async visitSpace(space: J.Space, p: P): Promise<J.Space> {
+    override async visitSpace(space: J.Space, p: P): Promise<J.Space> {
         return space;
     }
 

package/src/json/print.ts

@@ -75,7 +75,7 @@ class JsonPrinter extends JsonVisitor<PrintOutputCapture> {
         return jsonObject;
     }
 
-    protected async visitSpace(space: Json.Space, p: PrintOutputCapture): Promise<Json.Space> {
+    public async visitSpace(space: Json.Space, p: PrintOutputCapture): Promise<Json.Space> {
         p.append(space.whitespace);
         for (const comment of space.comments) {
             await this.visitMarkers(comment.markers, p);

package/src/json/rpc.ts

@@ -14,11 +14,10 @@
  * limitations under the License.
  */
 import {JsonVisitor} from "./visitor";
-import {asRef, RpcCodec, RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "../rpc";
+import {asRef, RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "../rpc";
 import {Json} from "./tree";
 import {produceAsync} from "../visitor";
 import {createDraft, Draft, finishDraft} from "immer";
-import {TreeKind} from "../tree";
 
 class JsonSender extends JsonVisitor<RpcSendQueue> {
 
@@ -76,7 +75,7 @@ class JsonSender extends JsonVisitor<RpcSendQueue> {
         return obj;
     }
 
-    protected async visitSpace(space: Json.Space, q: RpcSendQueue): Promise<Json.Space> {
+    public async visitSpace(space: Json.Space, q: RpcSendQueue): Promise<Json.Space> {
         await q.getAndSendList(space, s => s.comments, c => c.text + c.suffix, async c => {
             await q.getAndSend(c, c2 => c2.multiline);
             await q.getAndSend(c, c2 => c2.text);
@@ -87,7 +86,7 @@ class JsonSender extends JsonVisitor<RpcSendQueue> {
         return space;
     }
 
-    protected async visitRightPadded<T extends Json>(right: Json.RightPadded<T>, q: RpcSendQueue): Promise<Json.RightPadded<T> | undefined> {
+    public async visitRightPadded<T extends Json>(right: Json.RightPadded<T>, q: RpcSendQueue): Promise<Json.RightPadded<T> | undefined> {
         await q.getAndSend(right, r => r.element, j => this.visit(j, q));
         await q.getAndSend(right, r => asRef(r.after), async space => await this.visitSpace(space, q));
         await q.getAndSend(right, r => r.markers);
@@ -158,7 +157,7 @@ class JsonReceiver extends JsonVisitor<RpcReceiveQueue> {
         return finishDraft(draft);
     }
 
-    protected async visitSpace(space: Json.Space, q: RpcReceiveQueue): Promise<Json.Space> {
+    public async visitSpace(space: Json.Space, q: RpcReceiveQueue): Promise<Json.Space> {
         return produceAsync<Json.Space>(space, async draft => {
             draft.comments = await q.receiveListDefined(space.comments, async c => {
                 return await produceAsync(c, async draft => {
@@ -172,7 +171,7 @@ class JsonReceiver extends JsonVisitor<RpcReceiveQueue> {
         });
     }
 
-    protected async visitRightPadded<T extends Json>(right: Json.RightPadded<T>, p: RpcReceiveQueue): Promise<Json.RightPadded<T> | undefined> {
+    public async visitRightPadded<T extends Json>(right: Json.RightPadded<T>, p: RpcReceiveQueue): Promise<Json.RightPadded<T> | undefined> {
         if (!right) {
             throw new Error("TreeDataReceiveQueue should have instantiated an empty padding")
         }
@@ -184,18 +183,40 @@ class JsonReceiver extends JsonVisitor<RpcReceiveQueue> {
     }
 }
 
-const jsonCodec: RpcCodec<Json> = {
-    async rpcReceive(before: Json, q: RpcReceiveQueue): Promise<Json> {
-        return (await new JsonReceiver().visit(before, q))!;
-    },
-
-    async rpcSend(after: Json, q: RpcSendQueue): Promise<void> {
-        await new JsonSender().visit(after, q);
+const receiver = new JsonReceiver();
+const sender = new JsonSender();
+
+// Register codec for all Java AST node types
+for (const kind of Object.values(Json.Kind)) {
+    if (kind === Json.Kind.Space) {
+        RpcCodecs.registerCodec(kind, {
+            async rpcReceive(before: Json.Space, q: RpcReceiveQueue): Promise<Json.Space> {
+                return (await receiver.visitSpace(before, q))!;
+            },
+
+            async rpcSend(after: Json.Space, q: RpcSendQueue): Promise<void> {
+                await sender.visitSpace(after, q);
+            }
+        }, Json.Kind.Document);
+    } else if (kind === Json.Kind.RightPadded) {
+        RpcCodecs.registerCodec(kind, {
+            async rpcReceive<T extends Json>(before: Json.RightPadded<T>, q: RpcReceiveQueue): Promise<Json.RightPadded<T>> {
+                return (await receiver.visitRightPadded(before, q))!;
+            },
+
+            async rpcSend<T extends Json>(after: Json.RightPadded<T>, q: RpcSendQueue): Promise<void> {
+                await sender.visitRightPadded(after, q);
+            }
+        }, Json.Kind.Document);
+    } else {
+        RpcCodecs.registerCodec(kind as string, {
+            async rpcReceive(before: Json, q: RpcReceiveQueue): Promise<Json> {
+                return (await receiver.visit(before, q))!;
+            },
+
+            async rpcSend(after: Json, q: RpcSendQueue): Promise<void> {
+                await sender.visit(after, q);
+            }
+        }, Json.Kind.Document);
     }
 }
-
-Object.values(Json.Kind).forEach(kind => {
-    if (!Object.values(TreeKind).includes(kind as any)) {
-        RpcCodecs.registerCodec(kind, jsonCodec);
-    }
-});

package/src/json/visitor.ts

@@ -62,7 +62,7 @@ export class JsonVisitor<P> extends TreeVisitor<Json, P> {
         });
     }
 
-    protected async visitRightPadded<T extends Json>(right: Json.RightPadded<T>, p: P):
+    public async visitRightPadded<T extends Json>(right: Json.RightPadded<T>, p: P):
         Promise<Json.RightPadded<T> | undefined> {
         return produceAsync<Json.RightPadded<T>>(right, async draft => {
             draft.element = await this.visitDefined(right.element, p);
@@ -70,7 +70,7 @@ export class JsonVisitor<P> extends TreeVisitor<Json, P> {
         });
     }
 
-    protected async visitSpace(space: Json.Space, p: P): Promise<Json.Space> {
+    public async visitSpace(space: Json.Space, p: P): Promise<Json.Space> {
         return space;
     }
 

package/src/print.ts

@@ -143,11 +143,13 @@ export class TreePrinters {
      * @param target Helps to determine what kind of language we are dealing with when
      * printing a subtree whose LST type is shared between multiple languages in a language family.
      */
-    static printer(target: Cursor | SourceFile): TreePrinter {
-        const sourceFileKind = (isSourceFile(target) ?
+    static printer(target: Cursor | SourceFile | string): TreePrinter {
+        const sourceFileKind = typeof target === 'string' ?
+            target :
+            (isSourceFile(target) ?
                 target as SourceFile :
                 target.firstEnclosing(isSourceFile)
-        )!.kind
+            )!.kind
 
         if (!this._registry.has(sourceFileKind)) {
             throw new Error(`No printer registered for ${sourceFileKind}`)
@@ -160,6 +162,6 @@ export class TreePrinters {
     }
 }
 
-export function printer(target: Cursor | SourceFile): TreePrinter {
+export function printer(target: Cursor | SourceFile | string): TreePrinter {
     return TreePrinters.printer(target);
 }