Merge pull request #194 from digma-ai/feature/fix-js-error-parsing

Feature/fix js error parsing

Author: noamkfir

src/analyticsCodeLens.ts

@@ -8,7 +8,7 @@ import { CodeObjectLocationInfo } from './services/languages/extractors';
 import { CodeObjectUsageStatus, UsageStatusResults } from './services/analyticsProvider';
 
 
-export class AnaliticsCodeLens implements vscode.Disposable
+export class AnalyticsCodeLens implements vscode.Disposable
 {
 
     private _provider: CodelensProvider;

src/extension.ts

@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import { AnaliticsCodeLens } from './analyticsCodeLens';
+import { AnalyticsCodeLens } from './analyticsCodeLens';
 import { AnalyticsProvider} from './services/analyticsProvider';
 import { SymbolProvider } from './services/languages/symbolProvider';
 import { PythonLanguageExtractor } from "./services/languages/python/languageExtractor";
@@ -36,9 +36,9 @@ export async function activate(context: vscode.ExtensionContext)
     const codeInspector = new CodeInspector();
     const symbolProvider = new SymbolProvider(supportedLanguages, codeInspector);
     const analyticsProvider = new AnalyticsProvider(workspaceState);
-    const documentInfoProvider = new DocumentInfoProvider(analyticsProvider, symbolProvider,workspaceState);
+    const documentInfoProvider = new DocumentInfoProvider(analyticsProvider, symbolProvider, workspaceState);
     const editorHelper = new EditorHelper(sourceControl, documentInfoProvider);
-    const codeLensProvider = new AnaliticsCodeLens(documentInfoProvider,workspaceState)
+    const codeLensProvider = new AnalyticsCodeLens(documentInfoProvider, workspaceState);
 
     if(!workspaceState.environment){
         const firstEnv = (await analyticsProvider.getEnvironments()).firstOrDefault();

src/services/EditorHelper.ts

@@ -5,6 +5,7 @@ import { Logger } from './logger';
 import { SourceControl } from './sourceControl';
 import { DocumentInfoProvider } from './documentInfoProvider';
 import { Settings } from './../settings';
+import { ModulePathInfo } from './languages/modulePathToUriConverters';
 
 export interface EditorInfo {
     workspaceUri?: vscode.Uri;
@@ -29,80 +30,68 @@ export class EditorHelper {
         private _documentInfoProvider: DocumentInfoProvider,
     ) {}
 
-    public async goToFileAndLine(editorInfo?: EditorInfo)
-    {
+    public async goToFileAndLine(editorInfo?: EditorInfo) {
         if(!editorInfo?.workspaceUri) {
             return;
         }
 
         const workspaceUri = editorInfo.workspaceUri;
         const lineNumber = editorInfo.lineNumber ?? 0;
 
-        try
-        {
+        try {
             let doc: vscode.TextDocument | undefined = undefined;
 
-            if(!await utils.fileExists(workspaceUri))
-            {
+            if(!await utils.fileExists(workspaceUri)) {
                 doc = await this.askAndOpenFromSourceControl(editorInfo);
             }
-            else
-            {
+            else {
                 doc = await vscode.workspace.openTextDocument(workspaceUri);
 
                 const txtLine = doc.lineAt(lineNumber-1);
-                var fileChanged:boolean = false;
-                if (editorInfo.executedCode){
+                let fileChanged:boolean = false;
+                if (editorInfo.executedCode) {
                     fileChanged = (txtLine.text.trim() !== editorInfo.executedCode);
                 }
                 else {
                     try {
-                        var sourceDoc = await this.getFromSourceControl(workspaceUri, editorInfo.lastInstanceCommitId!);
-                        if (sourceDoc){
+                        const sourceDoc = await this.getFromSourceControl(workspaceUri, editorInfo.lastInstanceCommitId!);
+                        if (sourceDoc) {
                             fileChanged = (txtLine.text.trim() !== sourceDoc.lineAt(lineNumber-1).text.trim());
                         }
-                        else{
+                        else {
                             return;
                         }
                     }
-                    catch (exeption){
+                    catch(exeption) {
                         await vscode.window.showWarningMessage(
                             'Cannot locate file in source control. Please make sure its checked in');
                     }
-                
-
                 }
-                if(fileChanged)
-                {
+                if(fileChanged) {
                     doc = await this.askAndOpenFromSourceControl(editorInfo);;
                 }
-                else
-                {
+                else {
                     const docInfo = await this._documentInfoProvider.getDocumentInfo(doc);
                     const methodInfos = docInfo?.methods || [];
-                    if(methodInfos.all(m => m.symbol.name != editorInfo.functionName))
-                    {
+                    if(methodInfos.all(m => m.symbol.name != editorInfo.functionName)) {
                         doc = await this.askAndOpenFromSourceControl(editorInfo);
                     }
                 }
             }
 
-            if(doc)
-            {
+            if(doc) {
                 await this.openFileAndLine(doc, lineNumber); 
             }
         }
-        catch(error)
-        {
+        catch(error) {
             Logger.error(`Failed to open file: ${editorInfo.modulePhysicalPath}`, error);
             vscode.window.showErrorMessage(`Failed to open file: ${editorInfo.modulePhysicalPath}`)
         }
     }
 
-    public async openTextDocumentFromUri(uri: vscode.Uri) : Promise<vscode.TextDocument>{
+    public async openTextDocumentFromUri(uri: vscode.Uri) : Promise<vscode.TextDocument> {
         let doc = await vscode.workspace.openTextDocument(uri);
         return doc;
-
     }
 
     public async openFileAndLine(doc: vscode.TextDocument, lineNumber: number) {
@@ -117,18 +106,16 @@ export class EditorHelper {
         return await vscode.window.showTextDocument(doc);
     }
 
-    private async askAndOpenFromSourceControl(editorInfo: EditorInfo) : Promise<vscode.TextDocument | undefined>
-    {
-        if(!this._sourceControl.current)
-        {
+    private async askAndOpenFromSourceControl(editorInfo: EditorInfo) : Promise<vscode.TextDocument | undefined> {
+        if(!this._sourceControl.current) {
             const sel = await vscode.window.showWarningMessage(
                 'File version is different from the version recorded in this flow.\nPlease configure source control.',
                 'configure');
-            if(sel == 'configure')
+            if(sel == 'configure') {
                 await vscode.commands.executeCommand("workbench.action.openWorkspaceSettings", {query: Settings.sourceControl.key});
+            }
         }
-        else
-        {
+        else {
             let sel = await vscode.window.showWarningMessage(
                 `File version is different from the version recorded in this flow, would you like to open the remote version of the file' installed.`,
                 'yes'
@@ -155,54 +142,32 @@ export class EditorHelper {
         return await this._sourceControl.current?.getFile(uri, commit);
     }
 
-
-    public async getWorkspaceFileUri(editorInfo: EditorInfo) : Promise<vscode.Uri | undefined>    {
-        
-        const moduleLogicalPath = editorInfo.moduleLogicalPath;
-        //Try first using the logical name of the function if we have it
-        if (moduleLogicalPath){ 
-
-            var symbols = await this.lookupCodeObjectByFullName(moduleLogicalPath);
-            //We have a match
-            if (symbols.length===1){
-                return symbols[0].location.uri;
-            }
+    public async getWorkspaceFileUri(
+        pathInfo: ModulePathInfo,
+        document?: vscode.TextDocument,
+    ) : Promise<vscode.Uri | undefined> {
+        if(!document) {
+            return;
         }
 
-        const modulePhysicalPath = editorInfo.modulePhysicalPath;
-        if (modulePhysicalPath){
-
-            const moduleRootFolder = modulePhysicalPath.split('/').firstOrDefault();
-            const moduleWorkspace = vscode.workspace.workspaceFolders?.find(w => w.name === moduleRootFolder);
-            if (moduleWorkspace){
-        
-                const workspaceUri = moduleWorkspace
-                    ? vscode.Uri.joinPath(moduleWorkspace.uri, '..', modulePhysicalPath)
-                    : undefined;
-                
-                return workspaceUri;
-            }
-            else{
-                const file = await (await vscode.workspace.findFiles(modulePhysicalPath)).firstOrDefault();
-                return file;
-            }
-
-
+        const languageExtractor = await this._documentInfoProvider.symbolProvider.getSupportedLanguageExtractor(document);
+        if(!languageExtractor) {
+            return;
         }
 
-       
-    }
+        const converters = await languageExtractor.getModulePathToUriConverters();
+        let path;
+        for (let index = 0; !path && index < converters.length; index++) {
+            const converter = converters[index];
+            path = await converter.convert(pathInfo);
+        }
 
-    private async lookupCodeObjectByFullName(name:string) : Promise<vscode.SymbolInformation[]>{
-        return await vscode.commands.executeCommand("vscode.executeWorkspaceSymbolProvider", name);
+        return path;
     }
 
-
-
-
     public async getExecutedCodeFromScm(uri: vscode.Uri, commit: string, line: integer) : Promise<string |undefined>{
-        var doc = await this.getFromSourceControl(uri, commit);
-        if (doc){
+        const doc = await this.getFromSourceControl(uri, commit);
+        if (doc) {
             return doc.lineAt(line-1).text.trim();
         }
     }

src/services/languages/csharp/languageExtractor.ts

@@ -1,14 +1,14 @@
 import * as vscode from 'vscode';
 import { CodeInspector } from '../../codeInspector';
 import { IMethodExtractor, IParametersExtractor, ISpanExtractor } from '../extractors';
-import { LanguageExtractor } from "../languageExtractor";
+import { LanguageExtractor } from '../languageExtractor';
+import { IModulePathToUriConverter, LogicalModulePathToUriConverter, PhysicalModulePathToUriConverter } from '../modulePathToUriConverters';
 import { CSharpMethodExtractor } from './methodExtractor';
 import { CSharpParametersExtractor } from './parametersExtractor';
 import { CSharpSpanExtractor } from './spanExtractor';
 // import { AspNetCoreMvcEndpointExtractor } from './AspNetCoreMvcEndpointExtractor';
 
-export class CSharpLanguageExtractor extends LanguageExtractor 
-{
+export class CSharpLanguageExtractor extends LanguageExtractor {
     public requiredExtensionLoaded: boolean = false;
 
     public get requiredExtensionId(): string {
@@ -40,4 +40,11 @@ export class CSharpLanguageExtractor extends LanguageExtractor
             new CSharpSpanExtractor(codeInspector),
         ];
     }
+
+    public async getModulePathToUriConverters(): Promise<IModulePathToUriConverter[]> {
+        return [
+            new LogicalModulePathToUriConverter(),
+            new PhysicalModulePathToUriConverter(),
+        ];
+    }
 }

src/services/languages/go/languageExtractor.ts

@@ -3,11 +3,11 @@ import { CodeInspector } from '../../codeInspector';
 import { Logger } from '../../logger';
 import { IMethodExtractor, ISpanExtractor } from '../extractors';
 import { LanguageExtractor } from '../languageExtractor';
+import { IModulePathToUriConverter, LogicalModulePathToUriConverter, PhysicalModulePathToUriConverter } from '../modulePathToUriConverters';
 import { GoMethodExtractor } from './methodExtractor';
 import { GoSpanExtractor } from './spanExtractor';
 
-export class GoLanguageExtractor extends LanguageExtractor 
-{
+export class GoLanguageExtractor extends LanguageExtractor {
     public requiredExtensionLoaded: boolean = false;
 
     public get requiredExtensionId(): string {
@@ -45,4 +45,11 @@ export class GoLanguageExtractor extends LanguageExtractor
             Logger.info(`Finished activating "${extension.id}" extension`);
         }
     }
+
+    public async getModulePathToUriConverters(): Promise<IModulePathToUriConverter[]> {
+        return [
+            new LogicalModulePathToUriConverter(),
+            new PhysicalModulePathToUriConverter(),
+        ];
+    }
 }

src/services/languages/javascript/languageExtractor.ts

@@ -4,11 +4,14 @@ import { IMethodExtractor, ISpanExtractor } from '../extractors';
 import { LanguageExtractor } from '../languageExtractor';
 import { IMethodPositionSelector } from '../methodPositionSelector';
 import { JSMethodPositionSelector } from './methodPositionSelector';
+import { IModulePathToUriConverter } from '../modulePathToUriConverters';
 import { JSMethodExtractor } from './methodExtractor';
 import { JSSpanExtractor } from './spanExtractor';
+import { JSPackageReader } from './packageReader';
+import { JSPackageToUriConverter } from './modulePathToUriConverters';
 
-export class JSLanguageExtractor extends LanguageExtractor 
-{
+export class JSLanguageExtractor extends LanguageExtractor {
+    private packageReader: JSPackageReader = new JSPackageReader();
     public requiredExtensionLoaded: boolean = false;
 
     public get requiredExtensionId(): string {
@@ -21,7 +24,7 @@ export class JSLanguageExtractor extends LanguageExtractor
 
     public get methodExtractors(): IMethodExtractor[] {
         return [
-            new JSMethodExtractor()
+            new JSMethodExtractor(this.packageReader),
         ];
     }
 
@@ -34,4 +37,11 @@ export class JSLanguageExtractor extends LanguageExtractor
             new JSSpanExtractor(codeInspector)
         ];
     }
+
+    public async getModulePathToUriConverters(): Promise<IModulePathToUriConverter[]> {
+        const packagesMap = await this.packageReader.loadPackagesMap();
+        return [
+            new JSPackageToUriConverter(packagesMap),
+        ];
+    }
 }

src/services/languages/javascript/methodExtractor.ts

@@ -2,7 +2,6 @@ import * as vscode from 'vscode';
 import * as path from 'path';
 import { DocumentSymbol } from 'vscode-languageclient';
 import { IMethodExtractor, SymbolInfo } from '../extractors';
-import { Logger } from '../../logger';
 import { Token, TokenType } from '../tokens';
 import {
     MethodSymbolInfoExtractor,
@@ -11,20 +10,23 @@ import {
     AnonymousExpressRequestHandlerSymbolInfoExtractor,
     VariableFunctionSymbolInfoExtractor,
 } from './symbolInfoExtractors';
+import { JSPackageReader } from './packageReader';
 
 export class JSMethodExtractor implements IMethodExtractor {
 
+    constructor(
+        private packageReader: JSPackageReader,
+    ) {
+    }
+
     public async extractMethods(document: vscode.TextDocument, docSymbols: DocumentSymbol[], tokens: Token[]): Promise<SymbolInfo[]> {
-        const packages = await vscode.workspace.findFiles('**/package.json');
-        const packageFile = packages.find(f => document.uri.fsPath.startsWith(path.dirname(f.fsPath)));
+        const packageFile = await this.packageReader.findPackage(document.uri);
         if (!packageFile) {
-            Logger.warn(`Could not resolve package file for '${document.uri.path}'`);
             return [];
         }
 
-        let packageName = await this.getPackageName(packageFile);
-        if (packageName === undefined || packageName === "") {
-            Logger.warn(`Could not find package name in '${packageFile.path}'`);
+        let packageName = await this.packageReader.getPackageName(packageFile);
+        if (packageName === undefined) {
             return [];
         }
 
@@ -46,12 +48,6 @@ export class JSMethodExtractor implements IMethodExtractor {
         return this.extractFunctions(document, codeObjectPath, '', docSymbols, tokens);
     }
 
-    private async getPackageName(packageFile: vscode.Uri): Promise<string | undefined> {
-        const modDocument = await vscode.workspace.openTextDocument(packageFile);
-        const pkgjson = JSON.parse(modDocument.getText());
-        return pkgjson.name;
-    }
-
     private extractFunctions(document: vscode.TextDocument, codeObjectPath: string, parentSymbolPath: string, symbols: DocumentSymbol[], tokens: Token[]): SymbolInfo[] {
         const symbolInfos: SymbolInfo[] = [];
 
@@ -93,12 +89,10 @@ export class JSMethodExtractor implements IMethodExtractor {
         for (const symbol of symbols) {
             const symbolPath = (parentSymbolPath ? parentSymbolPath + '.' : '') + symbol.name;
 
-            const symbolInfo: SymbolInfo | undefined = symbolInfoExtractors.reduce(
-                (info: SymbolInfo | undefined, extractor) => info || extractor.extract(symbol, codeObjectPath, symbol.name, document, symbolPath),
-                undefined,
-            );
-            if(symbolInfo) {
-                symbolInfos.push(symbolInfo);
+            for (const extractor of symbolInfoExtractors) {
+                symbolInfos.push(
+                    ...extractor.extract(symbol, codeObjectPath, symbol.name, document, symbolPath)
+                );
             }
 
             const hasChildren = symbol.children && symbol.children.length > 0;