@openrewrite/rewrite 8.62.3 → 8.62.5

package/dist/javascript/type-mapping.js

@@ -30,16 +30,9 @@ class NonDraftableType {
     }
 }
 _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, projectRoot = process.cwd()) {
+    constructor(checker) {
         this.checker = checker;
-        this.projectRoot = projectRoot;
         this.typeCache = new Map();
         this.regExpSymbol = checker.resolveName("RegExp", undefined, typescript_1.default.SymbolFlags.Type, false);
     }
@@ -60,14 +53,8 @@ class JavaScriptTypeMapping {
         if (existing) {
             return existing;
         }
-        // Check if this is an array type BEFORE checking for classes
-        // TypeScript represents Array<T> as a reference to the Array interface
-        if (this.checker.isArrayType(type)) {
-            const arrayType = this.createArrayType(type);
-            this.typeCache.set(signature, arrayType);
-            return arrayType;
-        }
-        // Check for class/interface/enum types (but not arrays)
+        // Check for class/interface/enum types (including arrays)
+        // Arrays in JavaScript are objects with methods, so we treat them as class types
         const symbol = (_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)) {
@@ -120,7 +107,7 @@ class JavaScriptTypeMapping {
     }
     primitiveType(node) {
         const type = this.type(node);
-        if (java_1.Type.isClass(type) && type.fullyQualifiedName === 'lib.RegExp') {
+        if (java_1.Type.isClass(type) && type.fullyQualifiedName === 'RegExp') {
             return java_1.Type.Primitive.String;
         }
         return java_1.Type.isPrimitive(type) ? type : java_1.Type.Primitive.None;
@@ -136,6 +123,36 @@ class JavaScriptTypeMapping {
         }
         return undefined;
     }
+    /**
+     * Helper to create a Type.Method object from common parameters
+     */
+    createMethodType(signature, node, declaringType, name, declaredFormalTypeNames = []) {
+        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: name,
+            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);
+            }
+        });
+    }
     methodType(node) {
         let signature;
         let methodName;
@@ -148,29 +165,136 @@ class JavaScriptTypeMapping {
             if (!signature) {
                 return undefined;
             }
-            const symbol = this.checker.getSymbolAtLocation(node.expression);
+            let symbol = this.checker.getSymbolAtLocation(node.expression);
+            if (!symbol && typescript_1.default.isPropertyAccessExpression(node.expression)) {
+                // For property access expressions where we couldn't get a symbol,
+                // try to get the symbol from the signature's declaration
+                const declaration = signature === null || signature === void 0 ? void 0 : signature.getDeclaration();
+                if (declaration) {
+                    symbol = this.checker.getSymbolAtLocation(declaration);
+                }
+                // If still no symbol but we have a signature, we can proceed with limited info
+                if (!symbol && signature) {
+                    // For cases like util.isArray where the module is 'any' type
+                    // We'll construct a basic method type from the signature
+                    methodName = node.expression.name.getText();
+                    // When there's no symbol but we have a signature, we need to work harder
+                    // to find the declaring type. This happens with CommonJS require() calls
+                    // where the module is typed as 'any' but methods still have signatures
+                    // Try to trace back through the AST to find the require() call
+                    let inferredDeclaringType;
+                    const objExpr = node.expression.expression;
+                    if (typescript_1.default.isIdentifier(objExpr)) {
+                        // Look for the variable declaration that assigns the require() result
+                        const objSymbol = this.checker.getSymbolAtLocation(objExpr);
+                        if (objSymbol && objSymbol.valueDeclaration) {
+                            const valueDecl = objSymbol.valueDeclaration;
+                            if (typescript_1.default.isVariableDeclaration(valueDecl) && valueDecl.initializer) {
+                                // Check if it's a require() call
+                                if (typescript_1.default.isCallExpression(valueDecl.initializer)) {
+                                    const callExpr = valueDecl.initializer;
+                                    if (typescript_1.default.isIdentifier(callExpr.expression) &&
+                                        callExpr.expression.getText() === 'require' &&
+                                        callExpr.arguments.length > 0) {
+                                        // Extract the module name from require('module-name')
+                                        const moduleArg = callExpr.arguments[0];
+                                        if (typescript_1.default.isStringLiteral(moduleArg)) {
+                                            const moduleName = moduleArg.text;
+                                            inferredDeclaringType = {
+                                                kind: java_1.Type.Kind.Class,
+                                                fullyQualifiedName: moduleName
+                                            };
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // Use the inferred type or fall back to unknown
+                    declaringType = inferredDeclaringType || java_1.Type.unknownType;
+                    // Create the method type using the helper
+                    return this.createMethodType(signature, node, declaringType, methodName);
+                }
+            }
             if (!symbol) {
                 return undefined;
             }
             // Get the method name
             if (typescript_1.default.isPropertyAccessExpression(node.expression)) {
                 methodName = node.expression.name.getText();
+                // Check if the object is an imported symbol
+                const objSymbol = this.checker.getSymbolAtLocation(node.expression.expression);
+                let isImport = false;
+                if (objSymbol) {
+                    // Only call getAliasedSymbol if the symbol is actually an alias
+                    if (objSymbol.flags & typescript_1.default.SymbolFlags.Alias) {
+                        const aliasedSymbol = this.checker.getAliasedSymbol(objSymbol);
+                        isImport = aliasedSymbol && aliasedSymbol !== objSymbol;
+                    }
+                }
                 const exprType = this.checker.getTypeAtLocation(node.expression.expression);
                 const mappedType = this.getType(exprType);
-                // For string methods like 'hello'.split(), ensure we have a proper declaring type
-                if (!mappedType || mappedType.kind !== java_1.Type.Kind.Class) {
-                    // If the expression type is a primitive string, use lib.String as declaring type
+                // Handle different types
+                if (mappedType && mappedType.kind === java_1.Type.Kind.Class) {
+                    // Update the declaring type with the corrected FQN
+                    if (isImport && objSymbol) {
+                        const importName = objSymbol.getName();
+                        const origFqn = mappedType.fullyQualifiedName;
+                        const lastDot = origFqn.lastIndexOf('.');
+                        if (lastDot > 0) {
+                            const typeName = origFqn.substring(lastDot + 1);
+                            declaringType = {
+                                kind: java_1.Type.Kind.Class,
+                                fullyQualifiedName: `${importName}.${typeName}`
+                            };
+                        }
+                        else {
+                            declaringType = mappedType;
+                        }
+                    }
+                    else {
+                        declaringType = mappedType;
+                    }
+                }
+                else {
+                    // Handle primitive types and other non-class types
+                    if (mappedType) {
+                        if (mappedType.keyword === 'String') {
+                            declaringType = {
+                                kind: java_1.Type.Kind.Class,
+                                fullyQualifiedName: 'String'
+                            };
+                        }
+                        else if (mappedType.keyword === 'Number') {
+                            declaringType = {
+                                kind: java_1.Type.Kind.Class,
+                                fullyQualifiedName: 'Number'
+                            };
+                        }
+                        else {
+                            // Fallback for other types
+                            declaringType = mappedType;
+                        }
+                    }
+                    else {
+                        // Default to unknown if we can't determine the type
+                        declaringType = java_1.Type.unknownType;
+                    }
+                }
+                // For string methods like 'hello'.split(), ensure we have a proper declaring type for primitives
+                if (!isImport && declaringType === java_1.Type.unknownType) {
+                    // If the expression type is a primitive string, use String as declaring type
                     const typeString = this.checker.typeToString(exprType);
                     if (typeString === 'string' || exprType.flags & typescript_1.default.TypeFlags.String || exprType.flags & typescript_1.default.TypeFlags.StringLiteral) {
                         declaringType = {
                             kind: java_1.Type.Kind.Class,
-                            fullyQualifiedName: 'lib.String'
+                            fullyQualifiedName: 'string'
                         };
                     }
                     else if (typeString === 'number' || exprType.flags & typescript_1.default.TypeFlags.Number || exprType.flags & typescript_1.default.TypeFlags.NumberLiteral) {
                         declaringType = {
                             kind: java_1.Type.Kind.Class,
-                            fullyQualifiedName: 'lib.Number'
+                            fullyQualifiedName: 'number'
                         };
                     }
                     else {
@@ -178,44 +302,85 @@ class JavaScriptTypeMapping {
                         declaringType = java_1.Type.unknownType;
                     }
                 }
-                else {
-                    declaringType = mappedType;
-                }
             }
             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"
+                // Check if this is an import first
+                const symbol = this.checker.getSymbolAtLocation(node.expression);
+                let moduleSpecifier;
+                if (symbol) {
+                    // Check if this is an aliased symbol (i.e., an import)
+                    let aliasedSymbol;
+                    if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
+                        aliasedSymbol = this.checker.getAliasedSymbol(symbol);
+                    }
+                    // If getAliasedSymbol returns something different, it's an import
+                    if (aliasedSymbol && aliasedSymbol !== symbol) {
+                        // This is definitely an imported symbol
+                        // Now find the import declaration to get the module specifier
+                        if (symbol.declarations && symbol.declarations.length > 0) {
+                            let importNode = symbol.declarations[0];
+                            // Traverse up to find the ImportDeclaration
+                            while (importNode && !typescript_1.default.isImportDeclaration(importNode)) {
+                                importNode = importNode.parent;
+                            }
+                            if (importNode && typescript_1.default.isImportDeclaration(importNode)) {
+                                const importDeclNode = importNode;
+                                if (typescript_1.default.isStringLiteral(importDeclNode.moduleSpecifier)) {
+                                    moduleSpecifier = importDeclNode.moduleSpecifier.text;
+                                }
+                            }
+                        }
+                    }
+                }
+                if (moduleSpecifier) {
+                    // This is an imported function - use the module specifier as declaring type
+                    if (moduleSpecifier.startsWith('node:')) {
+                        // Node.js built-in module
                         declaringType = {
                             kind: java_1.Type.Kind.Class,
-                            fullyQualifiedName: fqn.substring(0, lastDot)
+                            fullyQualifiedName: 'node'
                         };
+                        methodName = moduleSpecifier.substring(5); // Remove 'node:' prefix
                     }
                     else {
-                        // No dots in the name - the type IS the module itself
-                        // This handles single-name modules like "axios", "lodash" etc.
-                        declaringType = funcType;
+                        // Regular module import
+                        declaringType = {
+                            kind: java_1.Type.Kind.Class,
+                            fullyQualifiedName: moduleSpecifier
+                        };
+                        methodName = '<default>';
                     }
                 }
                 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);
+                    // Fall back to the original logic for non-imported functions
+                    const exprType = this.checker.getTypeAtLocation(node.expression);
+                    const funcType = this.getType(exprType);
+                    if (funcType && funcType.kind === 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
+                            declaringType = {
+                                kind: java_1.Type.Kind.Class,
+                                fullyQualifiedName: fqn.substring(0, lastDot)
+                            };
+                        }
+                        else {
+                            // No dots in the name - the type IS the module itself
+                            declaringType = funcType;
+                        }
                     }
                     else {
-                        declaringType = java_1.Type.unknownType;
+                        // 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;
+                        }
                     }
                 }
             }
@@ -277,140 +442,96 @@ class JavaScriptTypeMapping {
             // 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);
-            }
-        });
+        // Create the method type using the helper
+        return this.createMethodType(signature, node, declaringType, methodName, declaredFormalTypeNames);
     }
     /**
      * Get the fully qualified name for a TypeScript type.
-     * Format: "module-specifier.TypeName" (e.g., "@mui/material.Button", "src/components/Button.Button")
+     * Uses TypeScript's built-in resolution which properly handles things like:
+     * - React.Component (not @types/react.Component)
+     * - _.LoDashStatic (not @types/lodash.LoDashStatic)
      */
     getFullyQualifiedName(type) {
-        var _b, _c;
+        var _b;
         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}`;
+        // First, check if this symbol is an import/alias
+        // For imported types, we want to use the module specifier instead of the file path
+        if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
+            const aliasedSymbol = this.checker.getAliasedSymbol(symbol);
+            if (aliasedSymbol && aliasedSymbol !== symbol && symbol.declarations && symbol.declarations.length > 0) {
+                // Try to find the import declaration to get the module specifier
+                let importNode = symbol.declarations[0];
+                // Traverse up to find the ImportDeclaration or ImportSpecifier
+                while (importNode && importNode.parent && !typescript_1.default.isImportDeclaration(importNode) && !typescript_1.default.isImportSpecifier(importNode)) {
+                    importNode = importNode.parent;
+                }
+                let moduleSpecifier;
+                if (importNode && typescript_1.default.isImportSpecifier(importNode)) {
+                    // Named import like: import { ClipLoader } from 'react-spinners'
+                    // ImportSpecifier -> NamedImports -> ImportClause -> ImportDeclaration
+                    const namedImports = importNode.parent; // NamedImports
+                    if (namedImports && typescript_1.default.isNamedImports(namedImports)) {
+                        const importClause = namedImports.parent; // ImportClause
+                        if (importClause && typescript_1.default.isImportClause(importClause)) {
+                            const importDecl = importClause.parent; // ImportDeclaration
+                            if (importDecl && typescript_1.default.isImportDeclaration(importDecl) && typescript_1.default.isStringLiteral(importDecl.moduleSpecifier)) {
+                                moduleSpecifier = importDecl.moduleSpecifier.text;
+                            }
                         }
-                        return `node.${modulePath}.${typeName}`;
                     }
-                    // Fallback for @types/node types that don't match the pattern
-                    return `node.${typeName}`;
                 }
-                return `${packageName}.${typeName}`;
+                else if (importNode && typescript_1.default.isImportDeclaration(importNode)) {
+                    // Default or namespace import
+                    if (typescript_1.default.isStringLiteral(importNode.moduleSpecifier)) {
+                        moduleSpecifier = importNode.moduleSpecifier.text;
+                    }
+                }
+                if (moduleSpecifier) {
+                    // Build the fully qualified name from module specifier + symbol name
+                    const symbolName = symbol.getName();
+                    return `${moduleSpecifier}.${symbolName}`;
+                }
             }
         }
-        // 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);
+        // Fall back to TypeScript's built-in getFullyQualifiedName
+        // This returns names with quotes that we need to clean up
+        // e.g., '"React"."Component"' -> 'React.Component'
+        const tsQualifiedName = this.checker.getFullyQualifiedName(symbol);
+        let cleanedName = tsQualifiedName.replace(/"/g, '');
+        // Check if this is a file path from node_modules (happens with some packages)
+        // TypeScript sometimes returns full paths instead of module names
+        if (cleanedName.includes('node_modules/')) {
+            // Extract the module name from the path
+            // Example: /private/var/.../node_modules/react-spinners/src/index.ClipLoader
+            // Should become: react-spinners.ClipLoader
+            const nodeModulesIndex = cleanedName.indexOf('node_modules/');
+            const afterNodeModules = cleanedName.substring(nodeModulesIndex + 'node_modules/'.length);
+            // Split by '/' to get parts of the path
+            const pathParts = afterNodeModules.split('/');
+            if (pathParts.length > 0) {
+                // First part is the package name (might be scoped like @types)
+                let packageName = pathParts[0];
+                // Handle scoped packages
+                if (packageName.startsWith('@') && pathParts.length > 1) {
+                    packageName = `${packageName}/${pathParts[1]}`;
+                }
+                // Find the symbol name (everything after the last dot in the original cleaned name)
+                const lastDotIndex = cleanedName.lastIndexOf('.');
+                if (lastDotIndex > 0) {
+                    const symbolName = cleanedName.substring(lastDotIndex + 1);
+                    cleanedName = `${packageName}.${symbolName}`;
+                }
+                else {
+                    cleanedName = packageName;
+                }
+            }
         }
-        // Remove leading slash and file extension
-        relativePath = relativePath.replace(/^\//, '').replace(/\.[^/.]+$/, '');
-        // Convert backslashes to forward slashes (for Windows)
-        relativePath = relativePath.replace(/\\/g, '/');
-        return relativePath;
+        return cleanedName.endsWith('Constructor') ?
+            cleanedName.substring(0, cleanedName.length - 'Constructor'.length) :
+            cleanedName;
     }
     /**
      * Create an empty JavaType.Class shell from a TypeScript type.
@@ -418,42 +539,8 @@ class JavaScriptTypeMapping {
      */
     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}.`);
-                    }
-                }
-            }
-        }
+        // Use our getFullyQualifiedName method which uses TypeScript's built-in resolution
+        const fullyQualifiedName = this.getFullyQualifiedName(type);
         // Determine the class kind based on symbol flags
         let classKind = java_1.Type.Class.Kind.Interface; // Default to interface
         const symbol = (_b = type.getSymbol) === null || _b === void 0 ? void 0 : _b.call(type);