filtering type parameters

Author: angrychow

ts-parser/src/parser/FunctionParser.ts

@@ -655,6 +655,12 @@ export class FunctionParser {
     const types: Dependency[] = [];
     const visited = new Set<string>();
 
+    // Collect all type parameter names from this node to filter them out
+    const typeParamNames = new Set<string>();
+    for (const typeParam of node.getTypeParameters()) {
+      typeParamNames.add(typeParam.getName());
+    }
+
     // Extract from type references and find their definitions
     const typeNodes: TypeNode[] = node.getDescendantsOfKind(SyntaxKind.TypeReference)
 
@@ -696,6 +702,10 @@ export class FunctionParser {
 
       if (directSymbol) {
         const directTypeName = directSymbol.getName();
+        // Skip if this is a type parameter
+        if (typeParamNames.has(directTypeName)) {
+          continue;
+        }
         if (!this.isPrimitiveType(directTypeName)) {
           const [resolvedSymbol, resolvedRealSymbol] = this.symbolResolver.resolveSymbol(directSymbol, typeNode);
           if (resolvedSymbol && !resolvedSymbol.isExternal) {
@@ -740,6 +750,11 @@ export class FunctionParser {
           continue;
         }
 
+        // Skip if this is a type parameter
+        if (typeParamNames.has(typeName)) {
+          continue;
+        }
+
         const symbol = typeRef.getSymbol();
         if (!symbol) {
           continue;

ts-parser/src/parser/TypeParser.ts

@@ -105,6 +105,12 @@ export class TypeParser {
     const content = cls.getFullText();
     const isExported = cls.isExported() || cls.isDefaultExport() || (sym === this.defaultExported && sym !== undefined);
 
+    // Collect type parameter names
+    const typeParamNames = new Set<string>();
+    for (const typeParam of cls.getTypeParameters()) {
+      typeParamNames.add(typeParam.getName());
+    }
+
     // Parse methods
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const methods: Record<string, any> = {};
@@ -128,7 +134,7 @@ export class TypeParser {
       const typeNodes = clause.getTypeNodes();
 
       for (const typeNode of typeNodes) {
-        const dependencies = this.extractTypeDependencies(typeNode, moduleName, packagePath);
+        const dependencies = this.extractTypeDependencies(typeNode, moduleName, packagePath, typeParamNames);
         if (clauseType === SyntaxKind.ImplementsKeyword) {
           implementsInterfaces.push(...dependencies);
         } else if (clauseType === SyntaxKind.ExtendsKeyword) {
@@ -170,6 +176,12 @@ export class TypeParser {
     const content = iface.getFullText();
     const isExported = iface.isExported() || iface.isDefaultExport() || (sym === this.defaultExported && sym !== undefined);
 
+    // Collect type parameter names
+    const typeParamNames = new Set<string>();
+    for (const typeParam of iface.getTypeParameters()) {
+      typeParamNames.add(typeParam.getName());
+    }
+
     // Parse methods
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const methods: Record<string, any> = {};
@@ -190,7 +202,7 @@ export class TypeParser {
       if (clause.getToken() === SyntaxKind.ExtendsKeyword) {
         const typeNodes = clause.getTypeNodes();
         for (const typeNode of typeNodes) {
-          const dependencies = this.extractTypeDependencies(typeNode, moduleName, packagePath);
+          const dependencies = this.extractTypeDependencies(typeNode, moduleName, packagePath, typeParamNames);
           extendsInterfaces.push(...dependencies);
         }
       }
@@ -229,11 +241,17 @@ export class TypeParser {
     const content = typeAlias.getFullText();
     const isExported = typeAlias.isExported() || typeAlias.isDefaultExport() || (sym === this.defaultExported && sym !== undefined);
 
+    // Collect type parameter names
+    const typeParamNames = new Set<string>();
+    for (const typeParam of typeAlias.getTypeParameters()) {
+      typeParamNames.add(typeParam.getName());
+    }
+
     // Extract type dependencies from the type alias
     const typeDependencies: Dependency[] = [];
     const typeNode = typeAlias.getTypeNode();
     if (typeNode) {
-      const dependencies = this.extractTypeDependencies(typeNode, moduleName, packagePath);
+      const dependencies = this.extractTypeDependencies(typeNode, moduleName, packagePath, typeParamNames);
       typeDependencies.push(...dependencies);
     }
 
@@ -290,7 +308,7 @@ export class TypeParser {
    * This handles union types, intersection types, generics, arrays, etc.
    * Uses SymbolResolver for consistent dependency resolution, similar to extractTypeReferences
    */
-  private extractTypeDependencies(typeNode: TypeNode, moduleName: string, packagePath: string): Dependency[] {
+  private extractTypeDependencies(typeNode: TypeNode, moduleName: string, packagePath: string, typeParamNames?: Set<string>): Dependency[] {
     const dependencies: Dependency[] = [];
     const visited = new Set<string>();
 
@@ -311,24 +329,29 @@ export class TypeParser {
       if (symbol) {
         const [resolvedSymbol, resolvedRealSymbol] = this.symbolResolver.resolveSymbol(symbol, typeNode);
         if (resolvedSymbol && !resolvedSymbol.isExternal) {
-          const decls = resolvedRealSymbol?.getDeclarations() || [];
-          if (decls.length > 0) {
-            const key = `${resolvedSymbol.moduleName}?${resolvedSymbol.packagePath}#${resolvedSymbol.name}`;
-
-            // Check if this is a self-reference: the type reference is within its own definition
-            const isSelfRef = typeNode.getAncestors().some(ancestor => ancestor === decls[0]);
-
-            if (!visited.has(key) && !isSelfRef) {
-              visited.add(key);
-              dependencies.push({
-                ModPath: resolvedSymbol.moduleName || moduleName,
-                PkgPath: this.getPkgPath(resolvedSymbol.packagePath || packagePath),
-                Name: resolvedSymbol.name,
-                File: resolvedSymbol.filePath,
-                Line: resolvedSymbol.line,
-                StartOffset: resolvedSymbol.startOffset,
-                EndOffset: resolvedSymbol.endOffset
-              });
+          // Skip if this is a type parameter
+          if (typeParamNames && typeParamNames.has(resolvedSymbol.name)) {
+            // Skip this type parameter
+          } else {
+            const decls = resolvedRealSymbol?.getDeclarations() || [];
+            if (decls.length > 0) {
+              const key = `${resolvedSymbol.moduleName}?${resolvedSymbol.packagePath}#${resolvedSymbol.name}`;
+
+              // Check if this is a self-reference: the type reference is within its own definition
+              const isSelfRef = typeNode.getAncestors().some(ancestor => ancestor === decls[0]);
+
+              if (!visited.has(key) && !isSelfRef) {
+                visited.add(key);
+                dependencies.push({
+                  ModPath: resolvedSymbol.moduleName || moduleName,
+                  PkgPath: this.getPkgPath(resolvedSymbol.packagePath || packagePath),
+                  Name: resolvedSymbol.name,
+                  File: resolvedSymbol.filePath,
+                  Line: resolvedSymbol.line,
+                  StartOffset: resolvedSymbol.startOffset,
+                  EndOffset: resolvedSymbol.endOffset
+                });
+              }
             }
           }
         }
@@ -363,6 +386,11 @@ export class TypeParser {
         continue;
       }
 
+      // Skip if this is a type parameter
+      if (typeParamNames && typeParamNames.has(resolvedSymbol.name)) {
+        continue;
+      }
+
       const key = `${resolvedSymbol.moduleName}?${resolvedSymbol.packagePath}#${resolvedSymbol.name}`;
       if (visited.has(key)) {
         continue;
@@ -424,6 +452,12 @@ export class TypeParser {
     const endOffset = classExpr.getEnd();
     const content = classExpr.getFullText();
 
+    // Collect type parameter names
+    const typeParamNames = new Set<string>();
+    for (const typeParam of classExpr.getTypeParameters()) {
+      typeParamNames.add(typeParam.getName());
+    }
+
     // Parse methods
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const methods: Record<string, any> = {};
@@ -447,7 +481,7 @@ export class TypeParser {
       const typeNodes = clause.getTypeNodes();
 
       for (const typeNode of typeNodes) {
-        const dependencies = this.extractTypeDependencies(typeNode, moduleName, packagePath);
+        const dependencies = this.extractTypeDependencies(typeNode, moduleName, packagePath, typeParamNames);
 
         if (clauseType === SyntaxKind.ImplementsKeyword) {
           implementsInterfaces.push(...dependencies);

ts-parser/test-repo/src/test-export-default.ts

@@ -12,11 +12,21 @@ export const bar = () => {
 
 export type Status = 'normal' | 'abnormal'
 
+export type Result<T> = T | Status
+
 export type ServerStatus = {
   code: number;
   status: Status;
 }
 
-export const flipStatus = (s: Status): Status => {
+export const convert = <T>(s: T): Result<T> => {
+  // 如果输入是字符串，返回 'normal'，否则返回输入本身
+  if (typeof s === 'string') {
+    return 'normal';
+  }
+  return s;
+};
+
+export const flipStatus = (s: Status): Result<Status> => {
   return s === 'normal' ? 'abnormal' : 'normal';
 }