@openrewrite/rewrite 8.62.0 → 8.62.2

package/dist/javascript/type-mapping.js

@@ -1,46 +1,8 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JavaScriptTypeMapping = void 0;
 /*
@@ -58,125 +20,633 @@ exports.JavaScriptTypeMapping = void 0;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const ts = __importStar(require("typescript"));
+const typescript_1 = __importDefault(require("typescript"));
 const java_1 = require("../java");
-const rpc_1 = require("../rpc");
+const immer_1 = require("immer");
+// Helper class to create Type objects that immer won't traverse
+class NonDraftableType {
+    constructor() {
+        this[_a] = false;
+    }
+}
+_a = immer_1.immerable;
+const builtInTypes = new Set([
+    'Array', 'Object', 'Function', 'String', 'Number', 'Boolean',
+    'Date', 'RegExp', 'Error', 'Promise', 'Map', 'Set', 'WeakMap',
+    'WeakSet', 'Symbol', 'BigInt', 'HTMLElement', 'Document',
+    'Window', 'Console', 'JSON', 'Math', 'Reflect', 'Proxy'
+]);
 class JavaScriptTypeMapping {
-    constructor(checker) {
+    constructor(checker, projectRoot = process.cwd()) {
         this.checker = checker;
+        this.projectRoot = projectRoot;
         this.typeCache = new Map();
-        this.regExpSymbol = checker.resolveName("RegExp", undefined, ts.SymbolFlags.Type, false);
+        this.regExpSymbol = checker.resolveName("RegExp", undefined, typescript_1.default.SymbolFlags.Type, false);
     }
     type(node) {
         let type;
-        if (ts.isExpression(node)) {
+        if (typescript_1.default.isExpression(node)) {
             type = this.checker.getTypeAtLocation(node);
         }
-        else if (ts.isTypeNode(node)) {
+        else if (typescript_1.default.isTypeNode(node)) {
             type = this.checker.getTypeFromTypeNode(node);
         }
         return type && this.getType(type);
     }
     getType(type) {
+        var _b;
         const signature = this.getSignature(type);
         const existing = this.typeCache.get(signature);
         if (existing) {
             return existing;
         }
-        const result = this.createType(type, signature);
+        // 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);
+            this.typeCache.set(signature, arrayType);
+            return arrayType;
+        }
+        // Check for class/interface/enum types (but not arrays)
+        const symbol = (_b = type.getSymbol) === null || _b === void 0 ? void 0 : _b.call(type);
+        if (symbol) {
+            if (symbol.flags & (typescript_1.default.SymbolFlags.Class | typescript_1.default.SymbolFlags.Interface | typescript_1.default.SymbolFlags.Enum | typescript_1.default.SymbolFlags.TypeAlias)) {
+                // Create and cache shell first to handle circular references
+                const classType = this.createEmptyClassType(type);
+                this.typeCache.set(signature, classType);
+                this.populateClassType(classType, type);
+                return classType;
+            }
+        }
+        // For anonymous object types that could have circular references
+        if (type.flags & typescript_1.default.TypeFlags.Object) {
+            const objectFlags = type.objectFlags;
+            if (objectFlags & typescript_1.default.ObjectFlags.Anonymous) {
+                // Anonymous object type - create and cache shell, then populate
+                const classType = this.createEmptyClassType(type);
+                this.typeCache.set(signature, classType);
+                this.populateClassType(classType, type);
+                return classType;
+            }
+        }
+        // For non-object types, we can create them directly without recursion concerns
+        const result = this.createPrimitiveOrUnknownType(type);
         this.typeCache.set(signature, result);
         return result;
     }
     getSignature(type) {
-        // FIXME for classes we need to include the containing module / package in the signature and probably include in the qualified name
-        if ("id" in type) { // a private field returned by the type checker
+        var _b, _c;
+        // Try to use TypeScript's internal id if available
+        if ("id" in type && type.id !== undefined) {
             return type.id;
         }
-        else {
-            throw new Error("no id property in type: " + JSON.stringify(type));
+        // Fallback: Generate a string signature based on type characteristics
+        const typeString = this.checker.typeToString(type);
+        const symbol = (_b = type.getSymbol) === null || _b === void 0 ? void 0 : _b.call(type);
+        if (symbol) {
+            const declaration = symbol.valueDeclaration || ((_c = symbol.declarations) === null || _c === void 0 ? void 0 : _c[0]);
+            if (declaration) {
+                const sourceFile = declaration.getSourceFile();
+                const fileName = sourceFile.fileName;
+                const pos = declaration.pos;
+                // Create unique signature from file + position + type string
+                // This ensures types from different modules are distinguished
+                return `${fileName}:${pos}:${typeString}`;
+            }
         }
+        // Last resort: use type string with a prefix to distinguish from numeric IDs
+        // This might happen for synthetic types or types without declarations
+        return `synthetic:${typeString}`;
     }
     primitiveType(node) {
         const type = this.type(node);
-        return java_1.JavaType.isPrimitive(type) ? type : java_1.JavaType.Primitive.None;
+        if (java_1.Type.isClass(type) && type.fullyQualifiedName === 'lib.RegExp') {
+            return java_1.Type.Primitive.String;
+        }
+        return java_1.Type.isPrimitive(type) ? type : java_1.Type.Primitive.None;
     }
     variableType(node) {
-        if (ts.isVariableDeclaration(node)) {
+        if (typescript_1.default.isVariableDeclaration(node)) {
             const symbol = this.checker.getSymbolAtLocation(node.name);
             if (symbol) {
-                const type = this.checker.getTypeOfSymbolAtLocation(symbol, node);
+                // TODO: Implement in Phase 6
+                // const type = this.checker.getTypeOfSymbolAtLocation(symbol, node);
+                // return JavaType.Variable with proper mapping
             }
         }
         return undefined;
     }
     methodType(node) {
-        return undefined;
+        let signature;
+        let methodName;
+        let declaringType;
+        let declaredFormalTypeNames = [];
+        // Handle different kinds of nodes that represent methods or method invocations
+        if (typescript_1.default.isCallExpression(node)) {
+            // For method invocations (e.g., _.map(...))
+            signature = this.checker.getResolvedSignature(node);
+            if (!signature) {
+                return undefined;
+            }
+            const symbol = this.checker.getSymbolAtLocation(node.expression);
+            if (!symbol) {
+                return undefined;
+            }
+            // Get the method name
+            if (typescript_1.default.isPropertyAccessExpression(node.expression)) {
+                methodName = node.expression.name.getText();
+                const exprType = this.checker.getTypeAtLocation(node.expression.expression);
+                declaringType = this.getType(exprType);
+            }
+            else if (typescript_1.default.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 === java_1.Type.Kind.Class) {
+                    const fqn = funcType.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"
+                        declaringType = {
+                            kind: java_1.Type.Kind.Class,
+                            fullyQualifiedName: fqn.substring(0, lastDot)
+                        };
+                    }
+                    else {
+                        // No dots in the name - the type IS the module itself
+                        // This handles single-name modules like "axios", "lodash" etc.
+                        declaringType = funcType;
+                    }
+                }
+                else {
+                    // Try to use the symbol's parent or module
+                    const parent = symbol.parent;
+                    if (parent) {
+                        const parentType = this.checker.getDeclaredTypeOfSymbol(parent);
+                        declaringType = this.getType(parentType);
+                    }
+                    else {
+                        declaringType = java_1.Type.unknownType;
+                    }
+                }
+            }
+            else {
+                methodName = symbol.getName();
+                declaringType = java_1.Type.unknownType;
+            }
+            // Get type parameters from signature
+            const typeParameters = signature.getTypeParameters();
+            if (typeParameters) {
+                for (const tp of typeParameters) {
+                    declaredFormalTypeNames.push(tp.symbol.getName());
+                }
+            }
+        }
+        else if (typescript_1.default.isMethodDeclaration(node) || typescript_1.default.isMethodSignature(node)) {
+            // For method declarations
+            const symbol = this.checker.getSymbolAtLocation(node.name);
+            if (!symbol) {
+                return undefined;
+            }
+            signature = this.checker.getSignatureFromDeclaration(node);
+            if (!signature) {
+                return undefined;
+            }
+            methodName = symbol.getName();
+            // Get the declaring type (the class/interface that contains this method)
+            const parent = node.parent;
+            if (typescript_1.default.isClassDeclaration(parent) || typescript_1.default.isInterfaceDeclaration(parent) || typescript_1.default.isObjectLiteralExpression(parent)) {
+                const parentType = this.checker.getTypeAtLocation(parent);
+                declaringType = this.getType(parentType);
+            }
+            else {
+                declaringType = java_1.Type.unknownType;
+            }
+            // Get type parameters from node
+            if (node.typeParameters) {
+                for (const tp of node.typeParameters) {
+                    declaredFormalTypeNames.push(tp.name.getText());
+                }
+            }
+        }
+        else if (typescript_1.default.isFunctionDeclaration(node) || typescript_1.default.isFunctionExpression(node)) {
+            // For function declarations/expressions
+            signature = this.checker.getSignatureFromDeclaration(node);
+            if (!signature) {
+                return undefined;
+            }
+            methodName = node.name ? node.name.getText() : "<anonymous>";
+            declaringType = java_1.Type.unknownType;
+            // Get type parameters from node
+            if (node.typeParameters) {
+                for (const tp of node.typeParameters) {
+                    declaredFormalTypeNames.push(tp.name.getText());
+                }
+            }
+        }
+        else {
+            // For other node types, return undefined
+            return undefined;
+        }
+        // Common logic for all method types
+        const returnType = signature.getReturnType();
+        const parameters = signature.getParameters();
+        const parameterTypes = [];
+        const parameterNames = [];
+        for (const param of parameters) {
+            parameterNames.push(param.getName());
+            const paramType = this.checker.getTypeOfSymbolAtLocation(param, node);
+            parameterTypes.push(this.getType(paramType));
+        }
+        // Create the Type.Method object
+        return Object.assign(new NonDraftableType(), {
+            kind: java_1.Type.Kind.Method,
+            declaringType: declaringType,
+            name: methodName,
+            returnType: this.getType(returnType),
+            parameterNames: parameterNames,
+            parameterTypes: parameterTypes,
+            thrownExceptions: [], // JavaScript doesn't have checked exceptions
+            annotations: [],
+            defaultValue: undefined,
+            declaredFormalTypeNames: declaredFormalTypeNames,
+            toJSON: function () {
+                return java_1.Type.signature(this);
+            }
+        });
+    }
+    /**
+     * Create a JavaType.Array from a TypeScript array type
+     */
+    createArrayType(type) {
+        // Get the element type (type argument of Array<T>)
+        const typeArgs = this.checker.getTypeArguments(type);
+        const elemType = typeArgs.length > 0 ? this.getType(typeArgs[0]) : java_1.Type.unknownType;
+        return Object.assign(new NonDraftableType(), {
+            kind: java_1.Type.Kind.Array,
+            elemType: elemType,
+            annotations: [],
+            toJSON: function () {
+                return java_1.Type.signature(this);
+            }
+        });
     }
-    createType(type, cacheKey) {
-        const signature = this.checker.typeToString(type);
+    /**
+     * Get the fully qualified name for a TypeScript type.
+     * Format: "module-specifier.TypeName" (e.g., "@mui/material.Button", "src/components/Button.Button")
+     */
+    getFullyQualifiedName(type) {
+        var _b, _c;
+        const symbol = (_b = type.getSymbol) === null || _b === void 0 ? void 0 : _b.call(type);
+        if (!symbol) {
+            return "unknown";
+        }
+        const typeName = symbol.getName();
+        const declaration = symbol.valueDeclaration || ((_c = symbol.declarations) === null || _c === void 0 ? void 0 : _c[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}`;
+        }
+        // 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}`;
+                        }
+                        // 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}`;
+                }
+                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"
+     */
+    extractPackageName(fileName) {
+        const match = fileName.match(/node_modules\/(@[^\/]+\/[^\/]+|[^\/]+)/);
+        return match ? match[1] : null;
+    }
+    /**
+     * Get relative module path from project root.
+     * Removes file extension and uses forward slashes.
+     */
+    getRelativeModulePath(fileName) {
+        // Remove project root and normalize path
+        let relativePath = fileName;
+        if (fileName.startsWith(this.projectRoot)) {
+            relativePath = fileName.slice(this.projectRoot.length);
+        }
+        // Remove leading slash and file extension
+        relativePath = relativePath.replace(/^\//, '').replace(/\.[^/.]+$/, '');
+        // Convert backslashes to forward slashes (for Windows)
+        relativePath = relativePath.replace(/\\/g, '/');
+        return relativePath;
+    }
+    /**
+     * Create an empty JavaType.Class shell from a TypeScript type.
+     * The shell will be populated later to handle circular references.
+     */
+    createEmptyClassType(type) {
+        var _b;
+        // 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}.`);
+                    }
+                }
+            }
+        }
+        // Determine the class kind based on symbol flags
+        let classKind = java_1.Type.Class.Kind.Interface; // Default to interface
+        const symbol = (_b = type.getSymbol) === null || _b === void 0 ? void 0 : _b.call(type);
+        if (symbol) {
+            if (symbol.flags & typescript_1.default.SymbolFlags.Class) {
+                classKind = java_1.Type.Class.Kind.Class;
+            }
+            else if (symbol.flags & typescript_1.default.SymbolFlags.Enum) {
+                classKind = java_1.Type.Class.Kind.Enum;
+            }
+            else if (symbol.flags & typescript_1.default.SymbolFlags.Interface) {
+                classKind = java_1.Type.Class.Kind.Interface;
+            }
+        }
+        // Create empty class type shell (no members yet to avoid recursion)
+        return Object.assign(new NonDraftableType(), {
+            kind: java_1.Type.Kind.Class,
+            classKind: classKind,
+            fullyQualifiedName: fullyQualifiedName,
+            typeParameters: [],
+            annotations: [],
+            interfaces: [],
+            members: [],
+            methods: [],
+            toJSON: function () {
+                return java_1.Type.signature(this);
+            }
+        });
+    }
+    /**
+     * Populates the class type with members, methods, heritage, and type parameters
+     * Since the shell is already in the cache, any recursive references will find it
+     */
+    populateClassType(classType, type) {
+        var _b, _c, _d, _e, _f, _g, _h, _j;
+        const symbol = (_b = type.getSymbol) === null || _b === void 0 ? void 0 : _b.call(type);
+        // Try to get base types using TypeScript's getBaseTypes API
+        // This works for both local and external types (from node_modules)
+        if (type.flags & typescript_1.default.TypeFlags.Object) {
+            let baseTypes;
+            // Check if this is a class or interface type that supports getBaseTypes
+            const objectType = type;
+            if (objectType.objectFlags & (typescript_1.default.ObjectFlags.Class | typescript_1.default.ObjectFlags.Interface)) {
+                try {
+                    baseTypes = (_d = (_c = this.checker).getBaseTypes) === null || _d === void 0 ? void 0 : _d.call(_c, type);
+                }
+                catch (e) {
+                    // getBaseTypes might fail for some types, fall back to declaration-based extraction
+                }
+            }
+            else if (symbol) {
+                // For constructor functions or type references, we need to get the actual class type
+                // Try to get the type of the class itself (not the constructor or instance)
+                const classSymbol = symbol.flags & typescript_1.default.SymbolFlags.Alias ?
+                    this.checker.getAliasedSymbol(symbol) : symbol;
+                if (classSymbol && classSymbol.flags & (typescript_1.default.SymbolFlags.Class | typescript_1.default.SymbolFlags.Interface)) {
+                    // Get the type of the class declaration itself
+                    const declaredType = this.checker.getDeclaredTypeOfSymbol(classSymbol);
+                    if (declaredType && declaredType !== type) {
+                        try {
+                            baseTypes = (_f = (_e = this.checker).getBaseTypes) === null || _f === void 0 ? void 0 : _f.call(_e, declaredType);
+                        }
+                        catch (e) {
+                            // getBaseTypes might fail, fall back to declaration-based extraction
+                        }
+                    }
+                }
+                else if (classSymbol && classSymbol.valueDeclaration && typescript_1.default.isClassDeclaration(classSymbol.valueDeclaration)) {
+                    // Handle the case where the symbol is for a class value (constructor function)
+                    // Get the instance type of the class
+                    const instanceType = this.checker.getDeclaredTypeOfSymbol(classSymbol);
+                    if (instanceType && instanceType !== type) {
+                        try {
+                            baseTypes = (_h = (_g = this.checker).getBaseTypes) === null || _h === void 0 ? void 0 : _h.call(_g, instanceType);
+                        }
+                        catch (e) {
+                            // getBaseTypes might fail, fall back to declaration-based extraction
+                        }
+                    }
+                }
+            }
+            if (baseTypes && baseTypes.length > 0) {
+                // For classes, the first base type is usually the superclass
+                // Additional base types are interfaces
+                if (classType.classKind === java_1.Type.Class.Kind.Class) {
+                    const firstBase = this.getType(baseTypes[0]);
+                    if (java_1.Type.isClass(firstBase)) {
+                        classType.supertype = firstBase;
+                    }
+                    // Rest are interfaces
+                    for (let i = 1; i < baseTypes.length; i++) {
+                        const interfaceType = this.getType(baseTypes[i]);
+                        if (java_1.Type.isClass(interfaceType)) {
+                            classType.interfaces.push(interfaceType);
+                        }
+                    }
+                }
+                else {
+                    // For interfaces, all base types are extended interfaces
+                    for (const baseType of baseTypes) {
+                        const interfaceType = this.getType(baseType);
+                        if (java_1.Type.isClass(interfaceType)) {
+                            classType.interfaces.push(interfaceType);
+                        }
+                    }
+                }
+            }
+        }
+        // Extract type parameters from declarations (not provided by getBaseTypes)
+        if (symbol === null || symbol === void 0 ? void 0 : symbol.declarations) {
+            for (const declaration of symbol.declarations) {
+                if (typescript_1.default.isClassDeclaration(declaration) || typescript_1.default.isInterfaceDeclaration(declaration)) {
+                    // Extract type parameters
+                    if (declaration.typeParameters) {
+                        for (const tp of declaration.typeParameters) {
+                            const tpType = this.checker.getTypeAtLocation(tp);
+                            classType.typeParameters.push(this.getType(tpType));
+                        }
+                    }
+                    break; // Only process the first declaration
+                }
+            }
+        }
+        // Get properties and methods
+        const properties = this.checker.getPropertiesOfType(type);
+        for (const prop of properties) {
+            const declaration = prop.valueDeclaration || ((_j = prop.declarations) === null || _j === void 0 ? void 0 : _j[0]);
+            if (!declaration) {
+                // Skip properties without declarations (synthetic/built-in properties)
+                continue;
+            }
+            if (prop.flags & typescript_1.default.SymbolFlags.Method) {
+                // TODO: Create Type.Method when method support is added
+                // For now, skip methods
+                continue;
+            }
+            else {
+                // Create Type.Variable for fields/properties
+                const propType = this.checker.getTypeOfSymbolAtLocation(prop, declaration);
+                const variable = Object.assign(new NonDraftableType(), {
+                    kind: java_1.Type.Kind.Variable,
+                    name: prop.getName(),
+                    owner: classType, // Cyclic reference to the containing class (already in cache)
+                    type: this.getType(propType), // This will find classType in cache if it's recursive
+                    annotations: [],
+                    toJSON: function () {
+                        return java_1.Type.signature(this);
+                    }
+                });
+                classType.members.push(variable);
+            }
+        }
+    }
+    /**
+     * Note: Object/Class/Interface types are handled in getType() to properly manage circular references
+     * This method should only be called for primitive and unknown types
+     */
+    createPrimitiveOrUnknownType(type) {
+        var _b;
+        // Check for literals first
         if (type.isLiteral()) {
             if (type.isNumberLiteral()) {
-                return java_1.JavaType.Primitive.Double;
+                return java_1.Type.Primitive.Double;
             }
             else if (type.isStringLiteral()) {
-                return java_1.JavaType.Primitive.String;
+                return java_1.Type.Primitive.String;
             }
         }
-        if (type.flags === ts.TypeFlags.Null) {
-            return java_1.JavaType.Primitive.Null;
+        // Check for primitive types
+        if (type.flags === typescript_1.default.TypeFlags.Null) {
+            return java_1.Type.Primitive.Null;
         }
-        else if (type.flags === ts.TypeFlags.Undefined) {
-            return java_1.JavaType.Primitive.None;
+        else if (type.flags === typescript_1.default.TypeFlags.Undefined) {
+            return java_1.Type.Primitive.None;
         }
-        else if (type.flags === ts.TypeFlags.Number ||
-            type.flags === ts.TypeFlags.NumberLiteral ||
-            type.flags === ts.TypeFlags.NumberLike) {
-            return java_1.JavaType.Primitive.Double;
+        else if (type.flags === typescript_1.default.TypeFlags.Number ||
+            type.flags === typescript_1.default.TypeFlags.NumberLiteral ||
+            type.flags === typescript_1.default.TypeFlags.NumberLike) {
+            return java_1.Type.Primitive.Double;
         }
-        else if (type.flags === ts.TypeFlags.String ||
-            type.flags === ts.TypeFlags.StringLiteral ||
-            type.flags === ts.TypeFlags.StringLike) {
-            return java_1.JavaType.Primitive.String;
+        else if (type.flags === typescript_1.default.TypeFlags.String ||
+            type.flags === typescript_1.default.TypeFlags.StringLiteral ||
+            type.flags === typescript_1.default.TypeFlags.StringLike) {
+            return java_1.Type.Primitive.String;
         }
-        else if (type.flags === ts.TypeFlags.Void) {
-            return java_1.JavaType.Primitive.Void;
+        else if (type.flags === typescript_1.default.TypeFlags.Void) {
+            return java_1.Type.Primitive.Void;
         }
-        else if (type.flags === ts.TypeFlags.BigInt ||
-            type.flags === ts.TypeFlags.BigIntLiteral ||
-            type.flags === ts.TypeFlags.BigIntLike) {
-            return java_1.JavaType.Primitive.Long;
+        else if (type.flags === typescript_1.default.TypeFlags.BigInt ||
+            type.flags === typescript_1.default.TypeFlags.BigIntLiteral ||
+            type.flags === typescript_1.default.TypeFlags.BigIntLike) {
+            return java_1.Type.Primitive.Long;
         }
         else if ((type.symbol !== undefined && type.symbol === this.regExpSymbol) ||
             this.checker.typeToString(type) === "RegExp") {
-            return java_1.JavaType.Primitive.String;
+            return java_1.Type.Primitive.String;
         }
         /**
          * TypeScript may assign multiple flags to a single type (e.g., Boolean + Union).
          * Using a bitwise check ensures we detect Boolean even if other flags are set.
          */
-        if (type.flags & ts.TypeFlags.Boolean ||
-            type.flags & ts.TypeFlags.BooleanLiteral ||
-            type.flags & ts.TypeFlags.BooleanLike) {
-            return java_1.JavaType.Primitive.Boolean;
-        }
-        // if (ts.isRegularExpressionLiteral(node)) {
-        //     return JavaType.Primitive.String;
-        // }
-        return java_1.JavaType.unknownType;
+        if (type.flags & typescript_1.default.TypeFlags.Boolean ||
+            type.flags & typescript_1.default.TypeFlags.BooleanLiteral ||
+            type.flags & typescript_1.default.TypeFlags.BooleanLike) {
+            return java_1.Type.Primitive.Boolean;
+        }
+        // Check for type aliases that may resolve to primitives
+        const symbol = (_b = type.getSymbol) === null || _b === void 0 ? void 0 : _b.call(type);
+        if (symbol && symbol.flags & typescript_1.default.SymbolFlags.TypeAlias) {
+            // Type aliases may resolve to primitive types
+            const aliasedType = this.checker.getDeclaredTypeOfSymbol(symbol);
+            if (aliasedType !== type) {
+                return this.getType(aliasedType);
+            }
+        }
+        return java_1.Type.unknownType;
     }
 }
 exports.JavaScriptTypeMapping = JavaScriptTypeMapping;
-rpc_1.RpcCodecs.registerCodec(java_1.JavaType.Kind.Primitive, {
-    rpcSend(after, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(after, p => p.keyword);
-        });
-    },
-    rpcReceive(before, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const keyword = yield q.receive(before.keyword);
-            return java_1.JavaType.Primitive.fromKeyword(keyword);
-        });
-    }
-});
 //# sourceMappingURL=type-mapping.js.map