fix type self-reference problem

Author: angrychow

ts-parser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abcoder-ts-parser",
-  "version": "0.0.13",
+  "version": "0.0.20",
   "description": "TypeScript AST parser for UNIAST specification",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

ts-parser/src/index.ts

@@ -11,7 +11,7 @@ const program = new Command();
 program
   .name('abcoder-ts-parser')
   .description('TypeScript AST parser for UNIAST specification')
-  .version('0.0.13');
+  .version('0.0.20');
 
 program
   .command('parse')

ts-parser/src/parser/FunctionParser.ts

@@ -705,12 +705,12 @@ export class FunctionParser {
               const defEndOffset = decls[0].getEnd();
               const key = `${resolvedSymbol.moduleName}?${resolvedSymbol.packagePath}#${resolvedSymbol.name}`;
 
-              // Check if this is not a self-reference within the same function
+              // Check if this is a self-reference (type reference within its own definition)
               const isSelfReference = (
                 resolvedSymbol.moduleName === moduleName &&
                 this.getPkgPath(resolvedSymbol.packagePath || packagePath) === packagePath &&
-                defEndOffset <= node.getEnd() &&
-                defStartOffset >= node.getStart()
+                defStartOffset <= resolvedSymbol.startOffset &&
+                resolvedSymbol.endOffset <= defEndOffset
               );
 
               if (!visited.has(key) && !isSelfReference) {
@@ -775,11 +775,12 @@ export class FunctionParser {
           EndOffset: resolvedSymbol.endOffset
         };
 
+        // Check if this is a self-reference (type reference within its own definition)
         if (
           dep.ModPath === moduleName &&
           dep.PkgPath === packagePath &&
-          defEndOffset <= node.getEnd() &&
-          defStartOffset >= node.getStart()
+          defStartOffset <= resolvedSymbol.startOffset &&
+          resolvedSymbol.endOffset <= defEndOffset
         ) {
           continue;
         }

ts-parser/src/parser/PackageParser.ts

@@ -29,7 +29,7 @@ export class PackageParser {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const vars: Record<string, any> = {};
 
-    for (const sourceFile of sourceFiles) {
+    for (const sourceFile of sourceFiles) {      
       // Parse functions
       const fileFunctions = this.functionParser.parseFunctions(sourceFile, moduleName, packagePath);
       Object.assign(functions, fileFunctions);

ts-parser/src/parser/TypeParser.ts

@@ -313,19 +313,12 @@ export class TypeParser {
         if (resolvedSymbol && !resolvedSymbol.isExternal) {
           const decls = resolvedRealSymbol?.getDeclarations() || [];
           if (decls.length > 0) {
-            const defStartOffset = decls[0].getStart();
-            const defEndOffset = decls[0].getEnd();
             const key = `${resolvedSymbol.moduleName}?${resolvedSymbol.packagePath}#${resolvedSymbol.name}`;
 
-            // Check if this is not a self-reference
-            const isSelfReference = (
-              resolvedSymbol.moduleName === moduleName &&
-              this.getPkgPath(resolvedSymbol.packagePath || packagePath) === packagePath &&
-              defStartOffset <= resolvedSymbol.startOffset &&
-              resolvedSymbol.endOffset <= defEndOffset
-            );
+            // 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) && !isSelfReference) {
+            if (!visited.has(key) && !isSelfRef) {
               visited.add(key);
               dependencies.push({
                 ModPath: resolvedSymbol.moduleName || moduleName,
@@ -380,8 +373,11 @@ export class TypeParser {
         continue;
       }
 
-      const defStartOffset = decls[0].getStart();
-      const defEndOffset = decls[0].getEnd();
+      // Check if this is a self-reference: the type reference is within its own definition
+      // If typeRef's ancestors include decls[0], it's a self-reference
+      const isSelfRef = typeRef.getAncestors().some(ancestor => ancestor === decls[0]);
+
+      if (isSelfRef) continue;
 
       visited.add(key);
       const dep: Dependency = {
@@ -394,13 +390,6 @@ export class TypeParser {
         EndOffset: resolvedSymbol.endOffset
       };
 
-      // Skip self-references
-      if (
-        dep.ModPath === moduleName &&
-        dep.PkgPath === packagePath &&
-        defStartOffset <= resolvedSymbol.startOffset &&
-        resolvedSymbol.endOffset <= defEndOffset
-      ) continue;
       dependencies.push(dep);
     }
 

ts-parser/src/parser/test/FunctionParser.test.ts

@@ -749,5 +749,39 @@ describe('FunctionParser', () => {
 
       cleanup();
     });
+
+    it('should filter out self-referencing recursive types', () => {
+      const { project, sourceFile, cleanup } = createTestProject(`
+        export type TreeNode = {
+          value: string;
+          children: TreeNode[];
+        };
+
+        export function processTree(node: TreeNode): void {
+          console.log(node.value);
+        }
+      `);
+
+      const parser = new FunctionParser(project, process.cwd());
+      let pkgPathAbsFile: string = sourceFile.getFilePath();
+      pkgPathAbsFile = pkgPathAbsFile.split('/').slice(0, -1).join('/');
+      const pkgPath = path.relative(process.cwd(), pkgPathAbsFile);
+
+      const functions = parser.parseFunctions(sourceFile, 'parser-tests', pkgPath);
+
+      const processTree = expectToBeDefined(functions['processTree']);
+
+      // Should have TreeNode in Types array
+      expect(processTree.Types).toBeDefined();
+      const typeNames = expectToBeDefined(processTree.Types).map(dep => dep.Name);
+
+      expect(typeNames).toContain('TreeNode');
+
+      // TreeNode should only appear once (the self-reference in TreeNode definition should be filtered)
+      const treeNodeCount = typeNames.filter(name => name === 'TreeNode').length;
+      expect(treeNodeCount).toBe(1);
+
+      cleanup();
+    });
   });
 });

ts-parser/src/parser/test/TypeParser.test.ts

@@ -671,5 +671,38 @@ describe('TypeParser', () => {
 
       cleanup();
     });
+
+    it('should filter out self-referencing recursive types in InlineStruct', () => {
+      const { project, sourceFile, cleanup } = createTestProject(`
+        export type TreeNode = {
+          value: string;
+          children: TreeNode[];
+        };
+
+        export type LinkedListNode = {
+          data: number;
+          next: LinkedListNode | null;
+        };
+      `);
+
+      const parser = new TypeParser(process.cwd());
+      let pkgPathAbsFile: string = sourceFile.getFilePath();
+      pkgPathAbsFile = pkgPathAbsFile.split('/').slice(0, -1).join('/');
+      const pkgPath = path.relative(process.cwd(), pkgPathAbsFile);
+
+      const types = parser.parseTypes(sourceFile, 'parser-tests', pkgPath);
+
+      // TreeNode should not include itself in InlineStruct (self-reference should be filtered)
+      const treeNode = expectToBeDefined(types['TreeNode']);
+      const treeNodeInlineNames = (treeNode.InlineStruct || []).map(dep => dep.Name);
+      expect(treeNodeInlineNames).not.toContain('TreeNode');
+
+      // LinkedListNode should not include itself in InlineStruct
+      const linkedListNode = expectToBeDefined(types['LinkedListNode']);
+      const linkedListInlineNames = (linkedListNode.InlineStruct || []).map(dep => dep.Name);
+      expect(linkedListInlineNames).not.toContain('LinkedListNode');
+
+      cleanup();
+    });
   });
 });

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

@@ -9,3 +9,14 @@ export default foo;
 export const bar = () => {
   console.log('baz')
 }
+
+export type Status = 'normal' | 'abnormal'
+
+export type ServerStatus = {
+  code: number;
+  status: Status;
+}
+
+export const flipStatus = (s: Status): Status => {
+  return s === 'normal' ? 'abnormal' : 'normal';
+}