@openrewrite/rewrite 8.62.0 → 8.62.2

package/src/java/visitor.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {isTree, SourceFile} from "../tree";
+import {Cursor, isTree, SourceFile} from "../tree";
 import {mapAsync} from "../util";
 import {produceAsync, TreeVisitor, ValidImmerRecipeReturnType} from "../visitor";
 import {
@@ -25,7 +25,7 @@ import {
     Statement, TypedTree, TypeTree
 } from "./tree";
 import {createDraft, Draft, finishDraft} from "immer";
-import {JavaType} from "./type";
+import {Type} from "./type";
 
 export class JavaVisitor<P> extends TreeVisitor<J, P> {
     // protected javadocVisitor: any | null = null;
@@ -50,7 +50,7 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
     }
 
     // noinspection JSUnusedLocalSymbols
-    protected async visitType(javaType: JavaType | undefined, p: P): Promise<JavaType | undefined> {
+    protected async visitType(javaType: Type | undefined, p: P): Promise<Type | undefined> {
         return javaType;
     }
 
@@ -241,7 +241,7 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
             draft.implements = await this.visitOptionalContainer(classDecl.implements, p);
             draft.permitting = await this.visitOptionalContainer(classDecl.permitting, p);
             draft.body = await this.visitDefined(classDecl.body, p) as J.Block;
-            draft.type = await this.visitType(classDecl.type, p) as JavaType.Class | undefined;
+            draft.type = await this.visitType(classDecl.type, p) as Type.Class | undefined;
         });
     }
 
@@ -426,7 +426,7 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
         return this.produceJava<J.Identifier>(ident, p, async draft => {
             draft.annotations = await mapAsync(ident.annotations, a => this.visitDefined<J.Annotation>(a, p));
             draft.type = await this.visitType(ident.type, p);
-            draft.fieldType = await this.visitType(ident.fieldType, p) as JavaType.Variable | undefined;
+            draft.fieldType = await this.visitType(ident.fieldType, p) as Type.Variable | undefined;
         });
     }
 
@@ -540,7 +540,7 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
         literal = expression as J.Literal;
 
         return this.produceJava<J.Literal>(literal, p, async draft => {
-            draft.type = await this.visitType(literal.type, p) as JavaType.Primitive | undefined;
+            draft.type = await this.visitType(literal.type, p) as Type.Primitive | undefined;
         });
     }
 
@@ -556,59 +556,59 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
             draft.typeParameters = await this.visitOptionalContainer(memberRef.typeParameters, p);
             draft.reference = await this.visitLeftPadded(memberRef.reference, p);
             draft.type = await this.visitType(memberRef.type, p);
-            draft.methodType = await this.visitType(memberRef.methodType, p) as JavaType.Method | undefined;
-            draft.variableType = await this.visitType(memberRef.variableType, p) as JavaType.Variable | undefined;
+            draft.methodType = await this.visitType(memberRef.methodType, p) as Type.Method | undefined;
+            draft.variableType = await this.visitType(memberRef.variableType, p) as Type.Variable | undefined;
         });
     }
 
-    protected async visitMethodDeclaration(methodDecl: J.MethodDeclaration, p: P): Promise<J | undefined> {
-        const statement = await this.visitStatement(methodDecl, p);
+    protected async visitMethodDeclaration(method: J.MethodDeclaration, p: P): Promise<J | undefined> {
+        const statement = await this.visitStatement(method, p);
         if (!statement?.kind || statement.kind !== J.Kind.MethodDeclaration) {
             return statement;
         }
-        methodDecl = statement as J.MethodDeclaration;
+        method = statement as J.MethodDeclaration;
 
-        return this.produceJava<J.MethodDeclaration>(methodDecl, p, async draft => {
-            draft.leadingAnnotations = await mapAsync(methodDecl.leadingAnnotations, a => this.visitDefined<J.Annotation>(a, p));
-            draft.modifiers = await mapAsync(methodDecl.modifiers, m => this.visitDefined<J.Modifier>(m, p));
+        return this.produceJava<J.MethodDeclaration>(method, p, async draft => {
+            draft.leadingAnnotations = await mapAsync(method.leadingAnnotations, a => this.visitDefined<J.Annotation>(a, p));
+            draft.modifiers = await mapAsync(method.modifiers, m => this.visitDefined<J.Modifier>(m, p));
 
-            if (methodDecl.typeParameters) {
-                draft.typeParameters = await this.visitDefined(methodDecl.typeParameters, p) as J.TypeParameters;
+            if (method.typeParameters) {
+                draft.typeParameters = await this.visitDefined(method.typeParameters, p) as J.TypeParameters;
             }
 
-            if (methodDecl.returnTypeExpression) {
-                draft.returnTypeExpression = await this.visitDefined(methodDecl.returnTypeExpression, p) as TypedTree;
+            if (method.returnTypeExpression) {
+                draft.returnTypeExpression = await this.visitDefined(method.returnTypeExpression, p) as TypedTree;
             }
 
-            draft.nameAnnotations = await mapAsync(methodDecl.nameAnnotations, a => this.visitDefined<J.Annotation>(a, p));
-            draft.name = await this.visitDefined(methodDecl.name, p);
-            draft.parameters = await this.visitContainer(methodDecl.parameters, p);
-            draft.throws = methodDecl.throws && await this.visitContainer(methodDecl.throws, p);
-            draft.body = methodDecl.body && await this.visitDefined(methodDecl.body, p) as J.Block;
-            draft.defaultValue = await this.visitOptionalLeftPadded(methodDecl.defaultValue, p);
-            draft.methodType = await this.visitType(methodDecl.methodType, p) as JavaType.Method | undefined;
+            draft.nameAnnotations = await mapAsync(method.nameAnnotations, a => this.visitDefined<J.Annotation>(a, p));
+            draft.name = await this.visitDefined(method.name, p);
+            draft.parameters = await this.visitContainer(method.parameters, p);
+            draft.throws = method.throws && await this.visitContainer(method.throws, p);
+            draft.body = method.body && await this.visitDefined(method.body, p) as J.Block;
+            draft.defaultValue = await this.visitOptionalLeftPadded(method.defaultValue, p);
+            draft.methodType = await this.visitType(method.methodType, p) as Type.Method | undefined;
         });
     }
 
-    protected async visitMethodInvocation(methodInv: J.MethodInvocation, p: P): Promise<J | undefined> {
-        const expression = await this.visitExpression(methodInv, p);
+    protected async visitMethodInvocation(method: J.MethodInvocation, p: P): Promise<J | undefined> {
+        const expression = await this.visitExpression(method, p);
         if (!expression?.kind || expression.kind !== J.Kind.MethodInvocation) {
             return expression;
         }
-        methodInv = expression as J.MethodInvocation;
+        method = expression as J.MethodInvocation;
 
-        const statement = await this.visitStatement(methodInv, p);
+        const statement = await this.visitStatement(method, p);
         if (!statement?.kind || statement.kind !== J.Kind.MethodInvocation) {
             return statement;
         }
-        methodInv = statement as J.MethodInvocation;
+        method = statement as J.MethodInvocation;
 
-        return this.produceJava<J.MethodInvocation>(methodInv, p, async draft => {
-            draft.select = await this.visitOptionalRightPadded(methodInv.select, p);
-            draft.typeParameters = await this.visitOptionalContainer(methodInv.typeParameters, p);
-            draft.name = await this.visitDefined(methodInv.name, p) as J.Identifier;
-            draft.arguments = await this.visitContainer(methodInv.arguments, p);
-            draft.methodType = await this.visitType(methodInv.methodType, p) as JavaType.Method | undefined;
+        return this.produceJava<J.MethodInvocation>(method, p, async draft => {
+            draft.select = await this.visitOptionalRightPadded(method.select, p);
+            draft.typeParameters = await this.visitOptionalContainer(method.typeParameters, p);
+            draft.name = await this.visitDefined(method.name, p) as J.Identifier;
+            draft.arguments = await this.visitContainer(method.arguments, p);
+            draft.methodType = await this.visitType(method.methodType, p) as Type.Method | undefined;
         });
     }
 
@@ -668,7 +668,7 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
                 draft.body = await this.visitDefined(newClass.body, p) as J.Block;
             }
 
-            draft.constructorType = await this.visitType(newClass.constructorType, p) as JavaType.Method | undefined;
+            draft.constructorType = await this.visitType(newClass.constructorType, p) as Type.Method | undefined;
         });
     }
 
@@ -729,7 +729,7 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
         primitive = expression as J.Primitive;
 
         return this.produceJava<J.Primitive>(primitive, p, async draft => {
-            draft.type = await this.visitType(primitive.type, p) as JavaType.Primitive;
+            draft.type = await this.visitType(primitive.type, p) as Type.Primitive;
         });
     }
 
@@ -947,7 +947,7 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
             draft.name = await this.visitDefined(variable.name, p) as J.Identifier;
             draft.dimensionsAfterName = await mapAsync(variable.dimensionsAfterName, dim => this.visitLeftPadded(dim, p));
             draft.initializer = await this.visitOptionalLeftPadded(variable.initializer, p);
-            draft.variableType = await this.visitType(variable.variableType, p) as JavaType.Variable | undefined;
+            draft.variableType = await this.visitType(variable.variableType, p) as Type.Variable | undefined;
         });
     }
 
@@ -997,11 +997,13 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
 
     protected async visitRightPadded<T extends J | boolean>(right: J.RightPadded<T>, p: P): Promise<J.RightPadded<T>> {
         return produceAsync<J.RightPadded<T>>(right, async draft => {
+            this.cursor = new Cursor(right, this.cursor);
             if (isTree(right.element)) {
                 (draft.element as J) = await this.visitDefined(right.element, p);
             }
             draft.after = await this.visitSpace(right.after, p);
             draft.markers = await this.visitMarkers(right.markers, p);
+            this.cursor = this.cursor.parent!;
         });
     }
 
@@ -1011,6 +1013,7 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
 
     protected async visitLeftPadded<T extends J | J.Space | number | string | boolean>(left: J.LeftPadded<T>, p: P): Promise<J.LeftPadded<T>> {
         return produceAsync<J.LeftPadded<T>>(left, async draft => {
+            this.cursor = new Cursor(left, this.cursor);
             draft.before = await this.visitSpace(left.before, p);
             if (isTree(left.element)) {
                 draft.element = await this.visitDefined(left.element, p) as Draft<T>;
@@ -1018,6 +1021,7 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
                 draft.element = await this.visitSpace(left.element, p) as Draft<T>;
             }
             draft.markers = await this.visitMarkers(left.markers, p);
+            this.cursor = this.cursor.parent!;
         });
     }
 
@@ -1027,9 +1031,11 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
 
     protected async visitContainer<T extends J>(container: J.Container<T>, p: P): Promise<J.Container<T>> {
         return produceAsync<J.Container<T>>(container, async draft => {
+            this.cursor = new Cursor(container, this.cursor);
             draft.before = await this.visitSpace(container.before, p);
             (draft.elements as J.RightPadded<J>[]) = await mapAsync(container.elements, e => this.visitRightPadded(e, p));
             draft.markers = await this.visitMarkers(container.markers, p);
+            this.cursor = this.cursor.parent!;
         });
     }
 

package/src/javascript/assertions.ts

@@ -17,16 +17,67 @@ import {AfterRecipeText, dedentAfter, SourceSpec} from "../test";
 import {JavaScriptParser} from "./parser";
 import {JS} from "./tree";
 import ts from 'typescript';
+import {json, Json} from "../json";
+import * as fs from "fs";
+import * as path from "path";
+import {execSync} from "child_process";
 
 const sourceFileCache: Map<string, ts.SourceFile> = new Map();
 
+export function* npm(relativeTo: string, ...sourceSpecs: SourceSpec<any>[]): Generator<SourceSpec<any>, void, unknown> {
+    for (const spec of sourceSpecs) {
+        if (spec.path === 'package.json') {
+            // Write package.json to disk so npm install can be run
+            fs.mkdirSync(relativeTo, {recursive: true});
+            const packageJsonPath = path.join(relativeTo, 'package.json');
+            
+            // Check if package.json already exists with the same content
+            let needsInstall = true;
+            if (fs.existsSync(packageJsonPath)) {
+                const existingContent = fs.readFileSync(packageJsonPath, 'utf-8');
+                if (existingContent === spec.before) {
+                    needsInstall = false;
+                }
+            }
+            
+            if (needsInstall) {
+                fs.writeFileSync(packageJsonPath, spec.before!);
+                execSync('npm install', {
+                    cwd: relativeTo,
+                    stdio: 'inherit' // Show npm output for debugging
+                });
+            }
+            yield spec;
+        }
+    }
+    for (const spec of sourceSpecs) {
+        if (spec.path !== 'package.json') {
+            if (spec.kind === JS.Kind.CompilationUnit) {
+                yield {
+                    ...spec,
+                    parser: () => new JavaScriptParser({sourceFileCache, relativeTo})
+                }
+            } else {
+                yield spec;
+            }
+        }
+    }
+}
+
+export function packageJson(before: string, after?: AfterRecipeText): SourceSpec<Json.Document> {
+    return {
+        ...json(before, after),
+        path: 'package.json'
+    };
+}
+
 export function javascript(before: string | null, after?: AfterRecipeText): SourceSpec<JS.CompilationUnit> {
     return {
         kind: JS.Kind.CompilationUnit,
         before: before,
         after: dedentAfter(after),
         ext: 'js',
-        parser: () => new JavaScriptParser({sourceFileCache})
+        parser: ctx => new JavaScriptParser({sourceFileCache})
     };
 }
 

package/src/javascript/format.ts

@@ -524,7 +524,7 @@ export class WrappingAndBracesVisitor<P> extends JavaScriptVisitor<P> {
     public async visitStatement(statement: Statement, p: P): Promise<Statement> {
         const j = await super.visitStatement(statement, p) as Statement;
         // TODO is it needed?
-        // const parent = this.cursor.parent?.value;
+        // const parent = this.cursor.parentTree()?.value;
         // if (parent?.kind === J.Kind.Block && j.kind !== J.Kind.EnumValueSet) {
         //     if (!j.prefix.whitespace.includes("\n")) {
         //         return produce(j, draft => {
@@ -537,7 +537,7 @@ export class WrappingAndBracesVisitor<P> extends JavaScriptVisitor<P> {
 
     protected async visitVariableDeclarations(multiVariable: J.VariableDeclarations, p: P): Promise<J.VariableDeclarations> {
         const v = await super.visitVariableDeclarations(multiVariable, p) as J.VariableDeclarations;
-        const parent = this.cursor.parent?.value;
+        const parent = this.cursor.parentTree()?.value;
         if (parent?.kind === J.Kind.Block) {
             return produce(v, draft => {
                 draft.leadingAnnotations = this.withNewlines(draft.leadingAnnotations);
@@ -939,8 +939,8 @@ export class BlankLinesVisitor<P> extends JavaScriptVisitor<P> {
 
     override async visitStatement(statement: Statement, p: P): Promise<Statement> {
         const ret = await super.visitStatement(statement, p) as Statement;
-        const parent = this.cursor.parent?.value;
-        const grandparent = this.cursor.parent?.parent?.value;
+        const parent = this.cursor.parentTree()?.value;
+        const grandparent = this.cursor.parentTree()?.parent?.value;
 
         return produce(ret, draft => {
             if (grandparent?.kind === J.Kind.ClassDeclaration && parent?.kind === J.Kind.Block) {

package/src/javascript/parser.ts

@@ -20,15 +20,15 @@ import {
     emptySpace,
     Expression,
     J,
-    JavaType,
     NameTree,
     Statement,
     TextComment,
     TrailingComma,
+    Type,
     TypeTree,
     VariableDeclarator,
 } from '../java';
-import {Generator, DelegatedYield, FunctionDeclaration, JS, JSX, NonNullAssertion, Optional, Spread} from '.';
+import {DelegatedYield, FunctionDeclaration, Generator, JS, JSX, NonNullAssertion, Optional, Spread} from '.';
 import {emptyMarkers, markers, Markers, MarkersKind, ParseExceptionResult} from "../markers";
 import {NamedStyles} from "../style";
 import {Parser, ParserInput, parserInputFile, parserInputRead, ParserOptions, Parsers, SourcePath} from "../parser";
@@ -76,11 +76,15 @@ export class JavaScriptParser extends Parser {
         this.compilerOptions = {
             target: ts.ScriptTarget.Latest,
             module: ts.ModuleKind.CommonJS,
+            moduleResolution: ts.ModuleResolutionKind.Node10,
             allowJs: true,
+            checkJs: true,
             esModuleInterop: true,
+            allowSyntheticDefaultImports: true,
             experimentalDecorators: true,
             emitDecoratorMetadata: true,
-            jsx: ts.JsxEmit.Preserve
+            jsx: ts.JsxEmit.Preserve,
+            baseUrl: relativeTo || process.cwd()
         };
         this.styles = styles;
         this.sourceFileCache = sourceFileCache;
@@ -107,6 +111,12 @@ export class JavaScriptParser extends Parser {
         // Create a new CompilerHost within parseInputs
         const host = ts.createCompilerHost(this.compilerOptions);
 
+        // Set the current directory for module resolution
+        if (this.relativeTo) {
+            const originalGetCurrentDirectory = host.getCurrentDirectory;
+            host.getCurrentDirectory = () => this.relativeTo || originalGetCurrentDirectory();
+        }
+
         // Override getSourceFile
         host.getSourceFile = (fileName, languageVersion, onError) => {
             // Check if the SourceFile is in the cache
@@ -159,6 +169,7 @@ export class JavaScriptParser extends Parser {
 
         const typeChecker = program.getTypeChecker();
 
+
         for (const input of inputFiles.values()) {
             const filePath = parserInputFile(input);
             const sourceFile = program.getSourceFile(filePath);
@@ -181,7 +192,7 @@ export class JavaScriptParser extends Parser {
 
             try {
                 yield produce(
-                    new JavaScriptParserVisitor(sourceFile, this.relativePath(input), typeChecker)
+                    new JavaScriptParserVisitor(sourceFile, this.relativePath(input), typeChecker, this.relativeTo || process.cwd())
                         .visit(sourceFile) as SourceFile,
                     draft => {
                         if (this.styles) {
@@ -211,8 +222,9 @@ export class JavaScriptParserVisitor {
     constructor(
         private readonly sourceFile: ts.SourceFile,
         private readonly sourcePath: string,
-        typeChecker: ts.TypeChecker) {
-        this.typeMapping = new JavaScriptTypeMapping(typeChecker);
+        typeChecker: ts.TypeChecker,
+        projectRoot?: string) {
+        this.typeMapping = new JavaScriptTypeMapping(typeChecker, projectRoot);
     }
 
     visit = (node: ts.Node): any => {
@@ -569,7 +581,22 @@ export class JavaScriptParserVisitor {
     }
 
     visitNumericLiteral(node: ts.NumericLiteral): J.Literal {
-        return this.mapLiteral(node, node.text); // FIXME value not in AST
+        // Parse the numeric value from the text
+        const text = node.text;
+        let value: number | bigint;
+
+        // Check if it's a BigInt literal (ends with 'n')
+        if (text.endsWith('n')) {
+            value = BigInt(text.slice(0, -1));
+        } else if (text.includes('.') || text.toLowerCase().includes('e')) {
+            // Floating point number
+            value = parseFloat(text);
+        } else {
+            // Integer - but JavaScript doesn't distinguish, so use number
+            value = parseInt(text, text.startsWith('0x') ? 16 : text.startsWith('0o') ? 8 : text.startsWith('0b') ? 2 : 10);
+        }
+
+        return this.mapLiteral(node, value);
     }
 
     visitTrueKeyword(node: ts.TrueLiteral): J.Literal {
@@ -653,11 +680,14 @@ export class JavaScriptParserVisitor {
     }
 
     visitBigIntLiteral(node: ts.BigIntLiteral): J.Literal {
-        return this.mapLiteral(node, node.text); // FIXME value not in AST
+        // Parse BigInt value, removing the 'n' suffix
+        const text = node.text;
+        const value = BigInt(text.slice(0, -1));
+        return this.mapLiteral(node, value);
     }
 
     visitStringLiteral(node: ts.StringLiteral): J.Literal {
-        return this.mapLiteral(node, node.text); // FIXME value not in AST
+        return this.mapLiteral(node, node.text);
     }
 
     visitRegularExpressionLiteral(node: ts.RegularExpressionLiteral): J.Literal {
@@ -693,8 +723,8 @@ export class JavaScriptParserVisitor {
             markers: emptyMarkers,
             annotations: [], // FIXME decorators
             simpleName: name,
-            type: type?.kind === JavaType.Kind.Variable ? (type as JavaType.Variable).type : type,
-            fieldType: type?.kind === JavaType.Kind.Variable ? type as JavaType.Variable : undefined
+            type: type?.kind === Type.Kind.Variable ? (type as Type.Variable).type : type,
+            fieldType: type?.kind === Type.Kind.Variable ? type as Type.Variable : undefined
         };
     }
 
@@ -1838,7 +1868,10 @@ export class JavaScriptParserVisitor {
                 markers: emptyMarkers,
                 select,
                 typeParameters: typeArguments,
-                name,
+                name: {
+                    ...name,
+                    type: undefined
+                },
                 arguments: this.mapCommaSeparatedList(node.getChildren(this.sourceFile).slice(-3)),
                 methodType: this.mapMethodType(node)
             }
@@ -3155,7 +3188,7 @@ export class JavaScriptParserVisitor {
                     emptySpace)],
                 end: this.prefix(node.getLastToken()!)
             },
-            type: this.mapType(node) as JavaType.Class
+            type: this.mapType(node) as Type.Class
         };
     }
 
@@ -4060,19 +4093,19 @@ export class JavaScriptParserVisitor {
         return this.prefix(getNextSibling(node)!, consume);
     }
 
-    private mapType(node: ts.Node): JavaType | undefined {
-        return Object.freeze(this.typeMapping.type(node));
+    private mapType(node: ts.Node): Type | undefined {
+        return this.typeMapping.type(node);
     }
 
-    private mapPrimitiveType(node: ts.Node): JavaType.Primitive {
+    private mapPrimitiveType(node: ts.Node): Type.Primitive {
         return this.typeMapping.primitiveType(node);
     }
 
-    private mapVariableType(node: ts.NamedDeclaration): JavaType.Variable | undefined {
+    private mapVariableType(node: ts.NamedDeclaration): Type.Variable | undefined {
         return this.typeMapping.variableType(node);
     }
 
-    private mapMethodType(node: ts.Node): JavaType.Method | undefined {
+    private mapMethodType(node: ts.Node): Type.Method | undefined {
         return this.typeMapping.methodType(node);
     }
 

package/src/javascript/rpc.ts

@@ -16,10 +16,10 @@
 import {JavaScriptVisitor} from "./visitor";
 import {asRef, RpcCodec, RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "../rpc";
 import {isJavaScript, JS, JSX} from "./tree";
-import {Expression, J, JavaType, Statement, TypedTree, TypeTree} from "../java";
+import {Expression, J, Statement, Type, TypedTree, TypeTree} from "../java";
 import {createDraft, finishDraft} from "immer";
 import {JavaReceiver, JavaSender} from "../java/rpc";
-import {Cursor, Tree, TreeKind} from "../tree";
+import {Cursor, Tree} from "../tree";
 import ComputedPropertyName = JS.ComputedPropertyName;
 
 class JavaScriptSender extends JavaScriptVisitor<RpcSendQueue> {
@@ -522,7 +522,7 @@ class JavaScriptSender extends JavaScriptVisitor<RpcSendQueue> {
         return this.javaSender.visitSpace(space, q);
     }
 
-    override async visitType(javaType: JavaType | undefined, q: RpcSendQueue): Promise<JavaType | undefined> {
+    override async visitType(javaType: Type | undefined, q: RpcSendQueue): Promise<Type | undefined> {
         return this.javaSender.visitType(javaType, q);
     }
 }
@@ -643,7 +643,7 @@ class JavaScriptReceiver extends JavaScriptVisitor<RpcReceiveQueue> {
         draft.function = await q.receive(functionCall.function, select => this.visitRightPadded(select, q));
         draft.typeParameters = await q.receive(functionCall.typeParameters, typeParams => this.visitContainer(typeParams, q));
         draft.arguments = await q.receive(functionCall.arguments, args => this.visitContainer(args, q));
-        draft.functionType = await q.receive(functionCall.functionType, type => this.visitType(type, q) as unknown as JavaType.Method);
+        draft.functionType = await q.receive(functionCall.functionType, type => this.visitType(type, q) as unknown as Type.Method);
 
         return finishDraft(draft);
     }
@@ -1020,7 +1020,7 @@ class JavaScriptReceiver extends JavaScriptVisitor<RpcReceiveQueue> {
         draft.name = await q.receive(draft.name, el => this.visitDefined<ComputedPropertyName>(el, q));
         draft.parameters = await q.receive(draft.parameters, el => this.visitContainer(el, q));
         draft.body = await q.receive(draft.body, el => this.visitDefined<J.Block>(el, q));
-        draft.methodType = await q.receive(draft.methodType, el => this.visitType(el, q) as any as JavaType.Method);
+        draft.methodType = await q.receive(draft.methodType, el => this.visitType(el, q) as any as Type.Method);
         return finishDraft(draft);
     }
 
@@ -1066,7 +1066,7 @@ class JavaScriptReceiver extends JavaScriptVisitor<RpcReceiveQueue> {
         draft.propertyName = await q.receive(draft.propertyName, el => this.visitRightPadded(el, q));
         draft.name = await q.receive(draft.name, el => this.visitDefined<TypedTree>(el, q));
         draft.initializer = await q.receive(draft.initializer, el => this.visitLeftPadded(el, q));
-        draft.variableType = await q.receive(draft.variableType, el => this.visitType(el, q) as any as JavaType.Variable);
+        draft.variableType = await q.receive(draft.variableType, el => this.visitType(el, q) as any as Type.Variable);
         return finishDraft(draft);
     }
 
@@ -1118,7 +1118,7 @@ class JavaScriptReceiver extends JavaScriptVisitor<RpcReceiveQueue> {
         return this.javaReceiverDelegate.visitSpace(space, q);
     }
 
-    override async visitType(javaType: JavaType | undefined, q: RpcReceiveQueue): Promise<JavaType | undefined> {
+    override async visitType(javaType: Type | undefined, q: RpcReceiveQueue): Promise<Type | undefined> {
         return this.javaReceiverDelegate.visitType(javaType, q);
     }
 }
@@ -1151,7 +1151,5 @@ const javaScriptCodec: RpcCodec<JS> = {
 
 // Register codec for all JavaScript AST node types
 Object.values(JS.Kind).forEach(kind => {
-    if (!Object.values(TreeKind).includes(kind as any)) {
-        RpcCodecs.registerCodec(kind, javaScriptCodec);
-    }
+    RpcCodecs.registerCodec(kind, javaScriptCodec);
 });