@openrewrite/rewrite 8.63.0 → 8.63.2

package/src/java/tree.ts

@@ -591,7 +591,7 @@ export namespace J {
 
     export interface Primitive extends J, TypeTree, Expression {
         readonly kind: typeof Kind.Primitive;
-        readonly type: Type.Primitive;
+        type: Type.Primitive;
     }
 
     export interface Return extends J, Statement {

package/src/java/type-visitor.ts

@@ -0,0 +1,241 @@
+/*
+ * 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.
+ */
+import {Cursor, rootCursor} from "../tree";
+import {mapAsync} from "../util";
+import {Type} from "./type";
+import {createDraft, Draft, finishDraft} from "immer";
+import {produceAsync, ValidImmerRecipeReturnType} from "../visitor";
+
+export class TypeVisitor<P> {
+    protected cursor: Cursor = rootCursor();
+
+    async visitList<T extends Type>(types: T[] | undefined, p: P): Promise<T[] | undefined> {
+        if (!types) {
+            return undefined;
+        }
+        return mapAsync(types, t => this.visit(t, p) as Promise<T>);
+    }
+
+    async preVisit(type: Type, p: P): Promise<Type | undefined> {
+        return type;
+    }
+
+    async postVisit(type: Type, p: P): Promise<Type | undefined> {
+        return type;
+    }
+
+    /**
+     * By calling this method, you are asserting that you know that the outcome will be non-null
+     * when the compiler couldn't otherwise prove this to be the case. This method is a shortcut
+     * for having to assert the non-nullability of the returned type.
+     *
+     * @param type A non-null type.
+     * @param p A state object that passes through the visitor.
+     * @return A non-null type.
+     */
+    async visitNonNull(type: Type, p: P): Promise<Type> {
+        const t = await this.visit(type, p);
+        if (!t) {
+            throw new Error("Expected non-null type");
+        }
+        return t;
+    }
+
+    async visit<T extends Type>(type: T | undefined, p: P): Promise<T | undefined> {
+        if (!type) {
+            return undefined;
+        }
+
+        this.cursor = new Cursor(type, this.cursor);
+
+        let result = await this.preVisit(type, p);
+        if (!result) {
+            this.cursor = this.cursor.parent!;
+            return undefined;
+        }
+
+        switch (result.kind) {
+            case Type.Kind.Array:
+                result = await this.visitArray(result as Type.Array, p);
+                break;
+            case Type.Kind.Annotation:
+                result = await this.visitAnnotation(result as Type.Annotation, p);
+                break;
+            case Type.Kind.Class:
+                result = await this.visitClass(result as Type.Class, p);
+                break;
+            case Type.Kind.GenericTypeVariable:
+                result = await this.visitGenericTypeVariable(result as Type.GenericTypeVariable, p);
+                break;
+            case Type.Kind.Intersection:
+                result = await this.visitIntersection(result as Type.Intersection, p);
+                break;
+            case Type.Kind.Union:
+                result = await this.visitUnion(result as Type.Union, p);
+                break;
+            case Type.Kind.Parameterized:
+                result = await this.visitParameterized(result as Type.Parameterized, p);
+                break;
+            case Type.Kind.Primitive:
+                result = await this.visitPrimitive(result as Type.Primitive, p);
+                break;
+            case Type.Kind.Method:
+                result = await this.visitMethod(result as Type.Method, p);
+                break;
+            case Type.Kind.Variable:
+                result = await this.visitVariable(result as Type.Variable, p);
+                break;
+            case Type.Kind.ShallowClass:
+                result = await this.visitClass(result as Type.ShallowClass, p);
+                break;
+            case Type.Kind.Unknown:
+                result = await this.visitUnknown(result, p);
+                break;
+        }
+
+        if (result) {
+            result = await this.postVisit(result, p);
+        }
+
+        this.cursor = this.cursor.parent!;
+        return result as T;
+    }
+
+    protected async visitUnion(union: Type.Union, p: P): Promise<Type | undefined> {
+        return this.produceType<Type.Union>(union, p, async draft => {
+            draft.bounds = await mapAsync(union.bounds || [], b => this.visit(b, p)) as Type[];
+        });
+    }
+
+    protected async visitAnnotation(annotation: Type.Annotation, p: P): Promise<Type | undefined> {
+        return this.produceType<Type.Annotation>(annotation, p, async draft => {
+            draft.type = await this.visit(annotation.type, p) as Type.FullyQualified;
+            // Note: values contain element values which themselves contain Type references
+            draft.values = await mapAsync(annotation.values || [], async v => {
+                const draftValue = createDraft(v);
+                draftValue.element = await this.visit(v.element, p) as Type;
+                if (v.kind === Type.Kind.SingleElementValue) {
+                    const single = v as Type.Annotation.SingleElementValue;
+                    if (single.referenceValue) {
+                        (draftValue as Draft<Type.Annotation.SingleElementValue>).referenceValue = await this.visit(single.referenceValue, p);
+                    }
+                } else if (v.kind === Type.Kind.ArrayElementValue) {
+                    const array = v as Type.Annotation.ArrayElementValue;
+                    if (array.referenceValues) {
+                        (draftValue as Draft<Type.Annotation.ArrayElementValue>).referenceValues = await mapAsync(
+                            array.referenceValues,
+                            rv => this.visit(rv, p)
+                        ) as Type[];
+                    }
+                }
+                return finishDraft(draftValue);
+            });
+        });
+    }
+
+    protected async visitArray(array: Type.Array, p: P): Promise<Type | undefined> {
+        return this.produceType<Type.Array>(array, p, async draft => {
+            draft.elemType = await this.visit(array.elemType, p) as Type;
+            draft.annotations = await this.visitList(array.annotations, p) as Type.Annotation[] || [];
+        });
+    }
+
+    protected async visitClass(aClass: Type.Class, p: P): Promise<Type | undefined> {
+        return this.produceType<Type.Class>(aClass, p, async draft => {
+            draft.supertype = await this.visit(aClass.supertype, p) as Type.Class | undefined;
+            draft.owningClass = await this.visit(aClass.owningClass, p) as Type.Class | undefined;
+            draft.annotations = await mapAsync(aClass.annotations || [], a => this.visit(a, p) as Promise<Type.Annotation>);
+            draft.interfaces = await mapAsync(aClass.interfaces || [], i => this.visit(i, p) as Promise<Type.Class>);
+            draft.members = await mapAsync(aClass.members || [], m => this.visit(m, p) as Promise<Type.Variable>);
+            draft.methods = await mapAsync(aClass.methods || [], m => this.visit(m, p) as Promise<Type.Method>);
+            draft.typeParameters = await this.visitList(aClass.typeParameters, p) as Type[] || [];
+        });
+    }
+
+    protected async visitGenericTypeVariable(generic: Type.GenericTypeVariable, p: P): Promise<Type | undefined> {
+        return this.produceType<Type.GenericTypeVariable>(generic, p, async draft => {
+            draft.bounds = await mapAsync(generic.bounds || [], b => this.visit(b, p)) as Type[];
+        });
+    }
+
+    protected async visitIntersection(intersection: Type.Intersection, p: P): Promise<Type | undefined> {
+        return this.produceType<Type.Intersection>(intersection, p, async draft => {
+            draft.bounds = await mapAsync(intersection.bounds || [], b => this.visit(b, p)) as Type[];
+        });
+    }
+
+    /**
+     * This does not visit the declaring type to avoid a visitor cycle.
+     *
+     * @param method The method to visit
+     * @param p Visit context
+     * @return A method
+     */
+    protected async visitMethod(method: Type.Method, p: P): Promise<Type | undefined> {
+        return this.produceType<Type.Method>(method, p, async draft => {
+            draft.declaringType = await this.visit(method.declaringType, p) as Type.FullyQualified;
+            draft.returnType = await this.visit(method.returnType, p) as Type;
+            draft.parameterTypes = await mapAsync(method.parameterTypes || [], pt => this.visit(pt, p)) as Type[];
+            draft.thrownExceptions = await mapAsync(method.thrownExceptions || [], t => this.visit(t, p)) as Type[];
+            draft.annotations = await mapAsync(method.annotations || [], a => this.visit(a, p) as Promise<Type.Annotation>);
+        });
+    }
+
+    protected async visitParameterized(parameterized: Type.Parameterized, p: P): Promise<Type | undefined> {
+        return this.produceType<Type.Parameterized>(parameterized, p, async draft => {
+            draft.type = await this.visit(parameterized.type, p) as Type.FullyQualified;
+            draft.typeParameters = await mapAsync(parameterized.typeParameters || [], t => this.visit(t, p)) as Type[];
+        });
+    }
+
+    protected async visitPrimitive(primitive: Type.Primitive, p: P): Promise<Type | undefined> {
+        // Primitives are immutable singletons, just return as-is
+        return primitive;
+    }
+
+    /**
+     * This does not visit the owner to avoid a visitor cycle.
+     *
+     * @param variable The variable to visit
+     * @param p Visit context
+     * @return A variable
+     */
+    protected async visitVariable(variable: Type.Variable, p: P): Promise<Type | undefined> {
+        return this.produceType<Type.Variable>(variable, p, async draft => {
+            draft.owner = await this.visit(variable.owner, p);
+            draft.type = await this.visit(variable.type, p) as Type;
+            draft.annotations = await mapAsync(variable.annotations || [], a => this.visit(a, p) as Promise<Type.Annotation>);
+        });
+    }
+
+    protected async visitUnknown(unknown: Type, p: P): Promise<Type | undefined> {
+        // Unknown types have no properties to visit
+        return unknown;
+    }
+
+    protected async produceType<T extends Type>(
+        before: T,
+        p: P,
+        recipe?: (draft: Draft<T>) =>
+            ValidImmerRecipeReturnType<Draft<T>> |
+            PromiseLike<ValidImmerRecipeReturnType<Draft<T>>>
+    ): Promise<T> {
+        if (recipe) {
+            return produceAsync<T>(before, recipe);
+        }
+        return before;
+    }
+}

package/src/java/type.ts

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {asRef, RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "../rpc";
-import {immerable} from "immer";
+import {asRef} from "../rpc";
 
 export interface Type {
     readonly kind: string;
@@ -41,6 +40,7 @@ export namespace Type {
 
     export interface Class extends Type, FullyQualified {
         readonly kind: typeof Kind.Class,
+        flags: number;
         classKind: Class.Kind;
         fullyQualifiedName: string;
         typeParameters: Type[];
@@ -91,6 +91,7 @@ export namespace Type {
 
     export interface Method extends Type {
         readonly kind: typeof Kind.Method;
+        flags: number;
         declaringType: Type.FullyQualified;
         name: string;
         returnType: Type;
@@ -301,37 +302,37 @@ export namespace Type {
             case Type.Kind.GenericTypeVariable: {
                 const generic = type as Type.GenericTypeVariable;
                 let result = "Generic{" + generic.name;
-                
+
                 // Initialize stack if needed
                 if (typeVariableNameStack === null) {
                     typeVariableNameStack = new Set<string>();
                 }
-                
+
                 // Check for recursion in type variable names
                 if (generic.name !== "?" && typeVariableNameStack.has(generic.name)) {
                     return result + "}";
                 }
-                
+
                 // Add to stack to track
                 if (generic.name !== "?") {
                     typeVariableNameStack.add(generic.name);
                 }
-                
+
                 try {
                     if (!generic.bounds || generic.bounds.length === 0) {
                         return result + "}";
                     }
-                    
+
                     // Filter out bounds that would cause cycles through parameterized types
                     const safeBounds = generic.bounds.filter(b => {
                         return !parameterizedStack || !parameterizedStack.has(b);
                     });
-                    
+
                     if (safeBounds.length > 0) {
                         const bounds = safeBounds.map(b => signature(b)).join(" & ");
                         result += " extends " + bounds;
                     }
-                    
+
                     return result + "}";
                 } finally {
                     // Remove from stack when done
@@ -352,15 +353,15 @@ export namespace Type {
             }
             case Type.Kind.Parameterized: {
                 const parameterized = type as Type.Parameterized;
-                
+
                 // Initialize stack if needed
                 if (parameterizedStack === null) {
                     parameterizedStack = new Set<Type>();
                 }
-                
+
                 // Add to stack to track cycles
                 parameterizedStack.add(parameterized);
-                
+
                 try {
                     const baseType = signature(parameterized.type);
                     if (!parameterized.typeParameters || parameterized.typeParameters.length === 0) {
@@ -399,268 +400,3 @@ export namespace Type {
         }
     }
 }
-
-RpcCodecs.registerCodec(Type.Kind.Primitive, {
-    async rpcSend(after: Type.Primitive, q: RpcSendQueue): Promise<void> {
-        await q.getAndSend(after, p => p.keyword);
-    },
-    async rpcReceive(before: Type.Primitive, q: RpcReceiveQueue): Promise<Type.Primitive> {
-        const keyword: string = await q.receive(before.keyword);
-        return Type.Primitive.fromKeyword(keyword)!;
-    }
-});
-
-RpcCodecs.registerCodec(Type.Kind.Class, {
-    async rpcSend(after: Type.Class, q: RpcSendQueue): Promise<void> {
-        await q.getAndSend(after, c => c.classKind);
-        await q.getAndSend(after, c => c.fullyQualifiedName);
-        await q.getAndSendList(after, c => (c.typeParameters || []).map(t => asRef(t)), t => Type.signature(t));
-        await q.getAndSend(after, c => asRef(c.supertype));
-        await q.getAndSend(after, c => asRef(c.owningClass));
-        await q.getAndSendList(after, c => (c.annotations || []).map(a => asRef(a)), t => Type.signature(t));
-        await q.getAndSendList(after, c => (c.interfaces || []).map(i => asRef(i)), t => Type.signature(t));
-        await q.getAndSendList(after, c => (c.members || []).map(m => asRef(m)), t => Type.signature(t));
-        await q.getAndSendList(after, c => (c.methods || []).map(m => asRef(m)), t => Type.signature(t));
-    },
-    async rpcReceive(before: Type.Class, q: RpcReceiveQueue): Promise<Type.Class> {
-        // Mutate the before object in place to preserve reference identity
-        before.classKind = await q.receive(before.classKind);
-        before.fullyQualifiedName = await q.receive(before.fullyQualifiedName);
-        before.typeParameters = await q.receiveList(before.typeParameters) || [];
-        before.supertype = await q.receive(before.supertype);
-        before.owningClass = await q.receive(before.owningClass);
-        before.annotations = await q.receiveList(before.annotations) || [];
-        before.interfaces = await q.receiveList(before.interfaces) || [];
-        before.members = await q.receiveList(before.members) || [];
-        before.methods = await q.receiveList(before.methods) || [];
-        (before as any).toJSON = function () {
-            return Type.signature(this);
-        };
-        // Mark as non-draftable to prevent immer from processing circular references
-        (before as any)[immerable] = false;
-
-        return before;
-    }
-});
-
-RpcCodecs.registerCodec(Type.Kind.Variable, {
-    async rpcSend(after: Type.Variable, q: RpcSendQueue): Promise<void> {
-        await q.getAndSend(after, v => v.name);
-        await q.getAndSend(after, v => v.owner ? asRef(v.owner) : undefined);
-        await q.getAndSend(after, v => asRef(v.type));
-        await q.getAndSendList(after, v => (v.annotations || []).map(v2 => asRef(v2)), t => Type.signature(t));
-    },
-    async rpcReceive(before: Type.Variable, q: RpcReceiveQueue): Promise<Type.Variable> {
-        // Mutate the before object in place to preserve reference identity
-        before.name = await q.receive(before.name);
-        before.owner = await q.receive(before.owner);
-        before.type = await q.receive(before.type);
-        before.annotations = await q.receiveList(before.annotations) || [];
-        return before;
-    }
-});
-
-RpcCodecs.registerCodec(Type.Kind.Annotation, {
-    async rpcSend(after: Type.Annotation, q: RpcSendQueue): Promise<void> {
-        await q.getAndSend(after, a => asRef(a.type));
-        await q.getAndSendList(after, a => (a.values || []).map(v => asRef(v)), v => {
-            let value: any;
-            if (v.kind === Type.Kind.SingleElementValue) {
-                const single = v as Type.Annotation.SingleElementValue;
-                value = single.constantValue !== undefined ? single.constantValue : single.referenceValue;
-            } else {
-                const array = v as Type.Annotation.ArrayElementValue;
-                value = array.constantValues || array.referenceValues;
-            }
-            return `${Type.signature(v.element)}:${value == null ? "null" : value.toString()}`;
-        });
-    },
-    async rpcReceive(before: Type.Annotation, q: RpcReceiveQueue): Promise<Type.Annotation> {
-        // Mutate the before object in place to preserve reference identity
-        before.type = await q.receive(before.type);
-        before.values = await q.receiveList(before.values) || [];
-        return before;
-    }
-});
-
-RpcCodecs.registerCodec(Type.Kind.SingleElementValue, {
-    async rpcSend(after: Type.Annotation.SingleElementValue, q: RpcSendQueue): Promise<void> {
-        await q.getAndSend(after, e => asRef(e.element));
-        await q.getAndSend(after, e => e.constantValue);
-        await q.getAndSend(after, e => asRef(e.referenceValue));
-    },
-    async rpcReceive(before: Type.Annotation.SingleElementValue | undefined, q: RpcReceiveQueue): Promise<Type.Annotation.SingleElementValue> {
-        if (!before) {
-            return {
-                kind: Type.Kind.SingleElementValue,
-                element: (await q.receive(undefined) as unknown) as Type,
-                constantValue: await q.receive(undefined),
-                referenceValue: await q.receive(undefined)
-            };
-        }
-        // Mutate the before object in place to preserve reference identity
-        before.element = await q.receive(before.element);
-        before.constantValue = await q.receive(before.constantValue);
-        before.referenceValue = await q.receive(before.referenceValue);
-        return before;
-    }
-});
-
-RpcCodecs.registerCodec(Type.Kind.ArrayElementValue, {
-    async rpcSend(after: Type.Annotation.ArrayElementValue, q: RpcSendQueue): Promise<void> {
-        await q.getAndSend(after, e => asRef(e.element));
-        await q.getAndSendList(after, e => e.constantValues || [], v => v == null ? "null" : v.toString());
-        await q.getAndSendList(after, e => (e.referenceValues || []).map(r => asRef(r)), t => Type.signature(t));
-    },
-    async rpcReceive(before: Type.Annotation.ArrayElementValue | undefined, q: RpcReceiveQueue): Promise<Type.Annotation.ArrayElementValue> {
-        if (!before) {
-            return {
-                kind: Type.Kind.ArrayElementValue,
-                element: (await q.receive(undefined) as unknown) as Type,
-                constantValues: await q.receiveList(undefined),
-                referenceValues: await q.receiveList(undefined)
-            };
-        }
-        // Mutate the before object in place to preserve reference identity
-        before.element = await q.receive(before.element);
-        before.constantValues = await q.receiveList(before.constantValues);
-        before.referenceValues = await q.receiveList(before.referenceValues);
-        return before;
-    }
-});
-
-RpcCodecs.registerCodec(Type.Kind.Method, {
-    async rpcSend(after: Type.Method, q: RpcSendQueue): Promise<void> {
-        await q.getAndSend(after, m => asRef(m.declaringType));
-        await q.getAndSend(after, m => m.name);
-        await q.getAndSend(after, m => asRef(m.returnType));
-        await q.getAndSendList(after, m => m.parameterNames || [], v => v);
-        await q.getAndSendList(after, m => (m.parameterTypes || []).map(t => asRef(t)), t => Type.signature(t));
-        await q.getAndSendList(after, m => (m.thrownExceptions || []).map(t => asRef(t)), t => Type.signature(t));
-        await q.getAndSendList(after, m => (m.annotations || []).map(a => asRef(a)), t => Type.signature(t));
-        await q.getAndSendList(after, m => m.defaultValue || undefined, v => v);
-        await q.getAndSendList(after, m => m.declaredFormalTypeNames || [], v => v);
-    },
-    async rpcReceive(before: Type.Method, q: RpcReceiveQueue): Promise<Type.Method> {
-        // Mutate the before object in place to preserve reference identity
-        before.declaringType = await q.receive(before.declaringType);
-        before.name = await q.receive(before.name);
-        before.returnType = await q.receive(before.returnType);
-        before.parameterNames = await q.receiveList(before.parameterNames) || [];
-        before.parameterTypes = await q.receiveList(before.parameterTypes) || [];
-        before.thrownExceptions = await q.receiveList(before.thrownExceptions) || [];
-        before.annotations = await q.receiveList(before.annotations) || [];
-        before.defaultValue = await q.receiveList(before.defaultValue);
-        before.declaredFormalTypeNames = await q.receiveList(before.declaredFormalTypeNames) || [];
-        return before;
-    }
-});
-
-RpcCodecs.registerCodec(Type.Kind.Array, {
-    async rpcSend(after: Type.Array, q: RpcSendQueue): Promise<void> {
-        await q.getAndSend(after, a => asRef(a.elemType));
-        await q.getAndSendList(after, a => (a.annotations || []).map(ann => asRef(ann)), t => Type.signature(t));
-    },
-    async rpcReceive(before: Type.Array, q: RpcReceiveQueue): Promise<Type.Array> {
-        // Mutate the before object in place to preserve reference identity
-        before.elemType = await q.receive(before.elemType);
-        before.annotations = await q.receiveList(before.annotations) || [];
-        return before;
-    }
-});
-
-RpcCodecs.registerCodec(Type.Kind.Parameterized, {
-    async rpcSend(after: Type.Parameterized, q: RpcSendQueue): Promise<void> {
-        await q.getAndSend(after, p => asRef(p.type));
-        await q.getAndSendList(after, p => (p.typeParameters || []).map(t => asRef(t)), t => Type.signature(t));
-    },
-    async rpcReceive(before: Type.Parameterized, q: RpcReceiveQueue): Promise<Type.Parameterized> {
-        // Mutate the before object in place to preserve reference identity
-        before.type = await q.receive(before.type);
-        before.typeParameters = await q.receiveList(before.typeParameters) || [];
-        return before;
-    }
-});
-
-RpcCodecs.registerCodec(Type.Kind.GenericTypeVariable, {
-    async rpcSend(after: Type.GenericTypeVariable, q: RpcSendQueue): Promise<void> {
-        await q.getAndSend(after, g => g.name);
-        // Convert TypeScript enum to Java enum string
-        await q.getAndSend(after, g => {
-            switch (g.variance) {
-                case Type.GenericTypeVariable.Variance.Covariant:
-                    return 'COVARIANT';
-                case Type.GenericTypeVariable.Variance.Contravariant:
-                    return 'CONTRAVARIANT';
-                case Type.GenericTypeVariable.Variance.Invariant:
-                default:
-                    return 'INVARIANT';
-            }
-        });
-        await q.getAndSendList(after, g => (g.bounds || []).map(b => asRef(b)), t => Type.signature(t));
-    },
-    async rpcReceive(before: Type.GenericTypeVariable, q: RpcReceiveQueue): Promise<Type.GenericTypeVariable> {
-        // Mutate the before object in place to preserve reference identity
-        before.name = await q.receive(before.name);
-        const varianceStr = await q.receive(before.variance) as any as string;
-        // Convert Java enum string to TypeScript enum
-        switch (varianceStr) {
-            case 'COVARIANT':
-                before.variance = Type.GenericTypeVariable.Variance.Covariant;
-                break;
-            case 'CONTRAVARIANT':
-                before.variance = Type.GenericTypeVariable.Variance.Contravariant;
-                break;
-            case 'INVARIANT':
-            default:
-                before.variance = Type.GenericTypeVariable.Variance.Invariant;
-                break;
-        }
-        before.bounds = await q.receiveList(before.bounds) || [];
-        return before;
-    }
-});
-
-RpcCodecs.registerCodec(Type.Kind.Union, {
-    async rpcSend(after: Type.Union, q: RpcSendQueue): Promise<void> {
-        await q.getAndSendList(after, u => (u.bounds || []).map(b => asRef(b)), t => Type.signature(t));
-    },
-    async rpcReceive(before: Type.Union, q: RpcReceiveQueue): Promise<Type.Union> {
-        // Mutate the before object in place to preserve reference identity
-        before.bounds = await q.receiveList(before.bounds) || [];
-        return before;
-    }
-});
-
-RpcCodecs.registerCodec(Type.Kind.Intersection, {
-    async rpcSend(after: Type.Intersection, q: RpcSendQueue): Promise<void> {
-        await q.getAndSendList(after, i => (i.bounds || []).map(b => asRef(b)), t => Type.signature(t));
-    },
-    async rpcReceive(before: Type.Intersection, q: RpcReceiveQueue): Promise<Type.Intersection> {
-        // Mutate the before object in place to preserve reference identity
-        before.bounds = await q.receiveList(before.bounds) || [];
-        return before;
-    }
-});
-
-RpcCodecs.registerCodec(Type.Kind.ShallowClass, {
-    async rpcSend(after: Type.ShallowClass, q: RpcSendQueue): Promise<void> {
-        await q.getAndSend(after, c => c.fullyQualifiedName);
-        await q.getAndSend(after, c => asRef(c.owningClass));
-    },
-    async rpcReceive(before: Type.ShallowClass, q: RpcReceiveQueue): Promise<Type.ShallowClass> {
-        before.classKind = Type.Class.Kind.Class;
-        before.fullyQualifiedName = await q.receive(before.fullyQualifiedName);
-        before.owningClass = await q.receive(before.owningClass);
-        return before;
-    }
-});
-
-RpcCodecs.registerCodec(Type.Kind.Unknown, {
-    async rpcSend(_after: Type, _q: RpcSendQueue): Promise<void> {
-        // Unknown type has no additional data
-    },
-    async rpcReceive(_before: Type, _q: RpcReceiveQueue): Promise<Type> {
-        return Type.unknownType;
-    }
-});