fix: self-reference detection and type alias dependency extraction (follow-up to #123) (#125)

* fix: use variable symbol instead of arrow function symbol for default export check

Fixed an issue where arrow function default export detection was checking
the arrow function's symbol instead of the variable declaration's symbol.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

* upd version

* fix: correct type alias symbol extraction from TypeReference nodes

Fixed type dependency recognition for type aliases (especially union types) across all parsers by extracting symbols from TypeReference node's typeName child instead of the node itself.

Changes:
- DependencyUtils: capture union/intersection type aliases before recursing into members
- TypeParser: extract symbols from typeName for TypeReference nodes, handle ExpressionWithTypeArguments, put type alias dependencies in InlineStruct instead of Implements
- FunctionParser: extract symbols from TypeReference typeName for function parameter/return types
- VarParser: extract symbols from TypeReference typeName for variable/property type annotations
- Added comprehensive unit tests for all three parsers

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

* fix type self-reference problem

* filtering type parameters

* support class parsing

* fix: if a property in a class is defined as a function, categorize it as a method

* fix bugs: construct symbol name by assignSymbolName

* update version

* add function parse

---------

Co-authored-by: Claude <[email protected]>

Author: angrychow

ts-parser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abcoder-ts-parser",
-  "version": "0.0.21",
+  "version": "0.0.24",
   "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.21');
+  .version('0.0.24');
 
 program
   .command('parse')

ts-parser/src/parser/FunctionParser.ts

@@ -9,6 +9,7 @@ import {
   MethodSignature,
   GetAccessorDeclaration,
   SetAccessorDeclaration,
+  PropertyDeclaration,
   Node,
   SyntaxKind,
   ParameterDeclaration,
@@ -122,8 +123,23 @@ export class FunctionParser {
           console.error('Error processing setter:', setter, error);
         }
       }
+
+      // Parse properties with function initializers (arrow functions or function expressions)
+      const properties = cls.getProperties();
+      for (const prop of properties) {
+        const initializer = prop.getInitializer();
+        if (initializer && (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer))) {
+          try {
+            const propObj = this.parsePropertyFunction(prop, initializer, moduleName, packagePath, sourceFile, className);
+            functions[propObj.Name] = propObj;
+          } catch (error) {
+            console.error('Error processing property function:', prop, error);
+          }
+        }
+      }
     }
 
+
     // Parse arrow functions assigned to variables
     const variableDeclarations = sourceFile.getVariableDeclarations();
     for (const varDecl of variableDeclarations) {
@@ -650,6 +666,88 @@ export class FunctionParser {
     };
   }
 
+  private parsePropertyFunction(
+    prop: PropertyDeclaration,
+    funcExpr: ArrowFunction | FunctionExpression,
+    moduleName: string,
+    packagePath: string,
+    sourceFile: SourceFile,
+    className: string
+  ): UniFunction {
+    const symbol = prop.getSymbol();
+    let propName = "";
+    if (symbol) {
+      propName = assignSymbolName(symbol);
+    } else {
+      propName = "anonymous_" + prop.getStart();
+    }
+    const startLine = prop.getStartLineNumber();
+    const startOffset = prop.getStart();
+    const endOffset = prop.getEnd();
+    const content = prop.getFullText();
+    const signature = this.extractSignature(funcExpr);
+
+    const parent = prop.getParent();
+    const parentSym = parent.getSymbol();
+    let isExported = false;
+    if (Node.isClassDeclaration(parent)) {
+      isExported = parent.isExported() || parent.isDefaultExport() || (this.defaultExportSymbol === parentSym && parentSym !== undefined);
+    } else if (Node.isClassExpression(parent)) {
+      const grandParent = parent.getParent();
+      if (Node.isVariableDeclaration(grandParent)) {
+        const varStatement = grandParent.getVariableStatement();
+        const varSymbol = grandParent.getSymbol();
+        isExported = varStatement ? (varStatement.isExported() || varStatement.isDefaultExport() || (this.defaultExportSymbol === varSymbol && varSymbol !== undefined)) : false;
+      }
+    }
+
+    // Parse receiver
+    const receiver: Receiver = {
+      IsPointer: false,
+      Type: {
+        ModPath: moduleName,
+        PkgPath: this.getPkgPath(packagePath),
+        Name: className
+      }
+    };
+
+    // Parse parameters
+    const params = this.parseParameters(funcExpr.getParameters(), moduleName, packagePath, sourceFile);
+
+    // Parse return types
+    const results = this.parseReturnTypes(funcExpr, moduleName, packagePath, sourceFile);
+
+    // Parse function calls
+    const functionCalls = this.extractFunctionCalls(funcExpr, moduleName, packagePath, sourceFile);
+    const methodCalls = this.extractMethodCalls(funcExpr, moduleName, packagePath, sourceFile);
+
+    // Extract type references and global variables
+    const types = this.extractTypeReferences(funcExpr, moduleName, packagePath, sourceFile);
+    const globalVars = this.extractGlobalVarReferences(funcExpr, moduleName, packagePath, sourceFile);
+
+    return {
+      ModPath: moduleName,
+      PkgPath: this.getPkgPath(packagePath),
+      Name: propName,
+      File: this.getRelativePath(sourceFile.getFilePath()),
+      Line: startLine,
+      StartOffset: startOffset,
+      EndOffset: endOffset,
+      Exported: isExported,
+      IsMethod: true,
+      IsInterfaceMethod: false,
+      Content: content,
+      Signature: signature,
+      Receiver: receiver,
+      Params: params,
+      Results: results,
+      FunctionCalls: functionCalls,
+      MethodCalls: methodCalls,
+      Types: types,
+      GlobalVars: globalVars
+    };
+  }
+
   // Parse parameters and extract type dependencies
   private parseParameters(parameters: ParameterDeclaration[], moduleName: string, packagePath: string, _sourceFile: SourceFile): Dependency[] {
     const dependencies: Dependency[] = [];