fault injection

Author: Hoblovski

.github/workflows/regression.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     #if: "!contains(github.event.pull_request.title, '[NO-REGRESSION-TEST]')"
     env:
-      LANGS: "go rust python java typescript"
+      LANGS: "typescript"
       DIFFJSON_IGNORE: "  ['id']   ['Path']  "
     steps:
       - name: Checkout pull request code

ts-parser/src/parser/FunctionParser.ts

@@ -41,116 +41,6 @@ export class FunctionParser {
 
   parseFunctions(sourceFile: SourceFile, moduleName: string, packagePath: string): Record<string, UniFunction> {
     const functions: Record<string, UniFunction> = {};
-
-    this.defaultExportSymbol = sourceFile.getDefaultExportSymbol()?.getAliasedSymbol()
-
-    // Parse function declarations
-    const functionDeclarations = sourceFile.getFunctions();
-    for (const func of functionDeclarations) {
-      try {
-        const funcObj = this.parseFunction(func, moduleName, packagePath, sourceFile);
-        functions[funcObj.Name] = funcObj;
-      } catch (error) {
-        console.error('Error processing function:', func, error);
-      }
-
-    }
-
-    // Parse method declarations in classes
-    const classes = sourceFile.getClasses();
-    for (const cls of classes) {
-      const sym = cls.getSymbol();
-      let className = ""
-      if (sym) {
-        className = assignSymbolName(sym)
-      } else {
-        className = "anonymous_" + cls.getStart()
-      }
-      const methods = cls.getMethods();
-
-      for (const method of methods) {
-        try {
-          const methodObj = this.parseMethod(method, moduleName, packagePath, sourceFile, className);
-          functions[methodObj.Name] = methodObj;
-        } catch (error) {
-          console.error('Error processing method:', method, error);
-        }
-      }
-
-      // Parse constructors
-      const constructors = cls.getConstructors();
-      for (const ctor of constructors) {
-        try {
-          const ctorObj = this.parseConstructor(ctor, moduleName, packagePath, sourceFile, className);
-          functions[ctorObj.Name] = ctorObj;
-        } catch (error) {
-          console.error('Error processing constructor:', ctor, error);
-        }
-      }
-
-      // Parse static methods
-      const staticMethods = cls.getStaticMethods();
-      for (const staticMethod of staticMethods) {
-        try {
-          const methodObj = this.parseMethod(staticMethod, moduleName, packagePath, sourceFile, className);
-          functions[methodObj.Name] = methodObj;
-        } catch (error) {
-          console.error('Error processing static method:', staticMethod, error);
-        }
-      }
-    }
-
-    // Parse arrow functions assigned to variables
-    const variableDeclarations = sourceFile.getVariableDeclarations();
-    for (const varDecl of variableDeclarations) {
-      const initializer = varDecl.getInitializer();
-      if (initializer && (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer))) {
-        const sym = varDecl.getSymbol()
-        let funcName = ""
-        if (sym) {
-          funcName = assignSymbolName(sym)
-        } else {
-          funcName = "anonymous_" + varDecl.getStart()
-        }
-        try {
-          const funcObj = this.parseArrowFunction(initializer, funcName, moduleName, packagePath, sourceFile, varDecl);
-          functions[funcObj.Name] = funcObj;
-        } catch (error) {
-          console.error('Error processing arrow function:', initializer, error);
-        }
-
-      }
-    }
-
-    // CORNER CASE: Parse arrow function declared as a default export
-    const defaultExport = sourceFile.getDefaultExportSymbol()
-    if (defaultExport !== undefined) {
-      const decl = defaultExport.getDeclarations()[0]
-      if(Node.isExportAssignment(decl)) {
-        const expr = decl.getExpression()
-        const funcName = assignSymbolName(defaultExport)
-        if(Node.isArrowFunction(expr)) {
-          const funcObj = this.parseArrowFunction(expr, funcName, moduleName, packagePath, sourceFile, decl);
-          functions[funcObj.Name] = funcObj;
-        }
-      }
-    }
-
-    // Parse interface methods
-    const interfaces = sourceFile.getInterfaces();
-    for (const iface of interfaces) {
-      const methods = iface.getMethods();
-
-      for (const method of methods) {
-        try {
-          const methodObj = this.parseInterfaceMethod(method, moduleName, packagePath, sourceFile);
-          functions[methodObj.Name] = methodObj;
-        } catch (error) {
-          console.error('Error processing interface method:', method, error);
-        }
-      }
-    }
-
     return functions;
   }