Added support in Golang (#100)

Author: asafc64

src/extension.ts

@@ -15,12 +15,14 @@ import { HotspotMarkerDecorator } from './decorators/hotspotMarkerDecorator';
 import { EditorHelper } from './services/EditorHelper';
 import { CodeInspector } from './services/codeInspector';
 import { VsCodeDebugInstrumentation } from './instrumentation/vscodeInstrumentation';
+import { GoLanguageExtractor } from './services/languages/go/languageExtractor';
 
 export async function activate(context: vscode.ExtensionContext) 
 {
     const supportedLanguages = [
         new PythonLanguageExtractor(),
-        new CSharpLanguageExtractor()
+        new CSharpLanguageExtractor(),
+        new GoLanguageExtractor()
     ];
     const supportedSourceControls = [
         new Git()

src/services/languages/csharp/methodExtractor.ts

@@ -5,7 +5,7 @@ import { IMethodExtractor, SymbolInfo } from "../extractors";
 
 export class CSharpMethodExtractor implements IMethodExtractor
 {
-    public extractMethods(document: vscode.TextDocument, docSymbols: DocumentSymbol[]): SymbolInfo[] {
+    public async extractMethods(document: vscode.TextDocument, docSymbols: DocumentSymbol[]): Promise<SymbolInfo[]> {
         const symbolInfos = this.extractFunctions(document.uri, document.uri.toModulePath(), '', docSymbols);
         return symbolInfos;
     }
@@ -42,7 +42,7 @@ export class CSharpMethodExtractor implements IMethodExtractor
                     id,
                     name: funcName,
                     codeLocation: namespace,
-                    displayName: namespace + "." + funcName,
+                    displayName: namespace.split('.').lastOrDefault() + "." + funcName,
                     range,
                     documentUri: uri,
                 });

src/services/languages/extractors.ts

@@ -43,7 +43,10 @@ export class SpanInfo implements CodeObjectInfo{
 
 
 export interface IMethodExtractor {
-    extractMethods(document: vscode.TextDocument, docSymbols: DocumentSymbol[]) : SymbolInfo[];
+    extractMethods(
+        document: vscode.TextDocument, 
+        docSymbols: DocumentSymbol[],
+        ) : Promise<SymbolInfo[]>;
 }
 
 export interface IEndpointExtractor {

src/services/languages/go/languageExtractor.ts

@@ -0,0 +1,33 @@
+import * as vscode from 'vscode';
+import { CodeInspector } from '../../codeInspector';
+import { IEndpointExtractor, ILanguageExtractor, IMethodExtractor, ISpanExtractor } from '../extractors';
+import { GoMethodExtractor } from './methodExtractor';
+
+
+
+export class GoLanguageExtractor implements ILanguageExtractor 
+{
+    public requiredExtensionLoaded: boolean = false;
+
+    public get requiredExtensionId(): string {
+        return 'golang.go';
+    }
+
+    public get documentFilter(): vscode.DocumentFilter {
+        return { scheme: 'file', language: 'go' };
+    }
+
+    public get methodExtractors(): IMethodExtractor[] {
+        return [
+            new GoMethodExtractor()
+        ];
+    }
+
+    public getEndpointExtractors(codeInspector: CodeInspector): IEndpointExtractor[] {
+        return [];
+    }
+
+    public getSpanExtractors(codeInspector: CodeInspector): ISpanExtractor[] {
+        return [];
+    }
+}

src/services/languages/go/methodExtractor.ts

@@ -0,0 +1,61 @@
+import * as vscode from 'vscode';
+import * as path from 'path';
+import { DocumentSymbol, SymbolKind } from "vscode-languageclient";
+import { IMethodExtractor, SymbolInfo } from "../extractors";
+import { Logger } from '../../logger';
+
+export class GoMethodExtractor implements IMethodExtractor{
+    public async extractMethods(document: vscode.TextDocument, docSymbols: DocumentSymbol[]): Promise<SymbolInfo[]> {
+        const methodSymbols = docSymbols.filter(s => s.kind+1 === SymbolKind.Method || s.kind+1 === SymbolKind.Function); 
+        if(!methodSymbols.length)
+            return [];
+
+        const modFiles = await vscode.workspace.findFiles('**/go.mod');
+        const modFile = modFiles.find(f => document.uri.path.startsWith(path.dirname(f.path)))
+        if(!modFile){
+            Logger.warn(`Could not resolve mod file for '${document.uri.path}'`)
+            return [];
+        }
+
+        const modFolder = path.dirname(modFile.path);
+        const docFolder = path.dirname(document.uri.path);
+        let packageName = '';
+        if(modFolder === docFolder){
+            const match = document.getText().match(/^package (.+)$/m);
+            if(!match){
+                Logger.warn(`Could not found packakge name in '${document.uri.path}'`)
+                return [];
+            }
+            packageName = match[1]; 
+        }
+        if(!packageName || packageName !== 'main'){
+            const modDocument = await vscode.workspace.openTextDocument(modFile);
+            const match = modDocument.getText().match(/^module (.+)$/m);
+            if(!match){
+                Logger.warn(`Could not found module name in '${modFile.path}'`)
+                return [];
+            }
+            packageName = match[1] 
+            
+            if(modFolder !== docFolder)
+                packageName += '/' + path.relative(modFolder, docFolder);
+        }
+
+        const methods: SymbolInfo[] = methodSymbols.map(s => {
+            return {
+                id: packageName + '$_$' + s.name,
+                name: s.name,
+                displayName: packageName.split('/').lastOrDefault() + '.' + s.name,
+                documentUri: document.uri,
+                codeLocation: packageName,
+                range: new vscode.Range(
+                    new vscode.Position(s.range.start.line, s.range.start.character),
+                    new vscode.Position(s.range.end.line, s.range.end.character)
+                )
+            }
+        });
+
+        return methods;
+    }
+    
+}

src/services/languages/python/methodExtractor.ts

@@ -5,7 +5,7 @@ import { IMethodExtractor, SymbolInfo } from "../extractors";
 
 export class PythonMethodExtractor implements IMethodExtractor
 {
-    public extractMethods(document: vscode.TextDocument, docSymbols: DocumentSymbol[]): SymbolInfo[] {
+    public async extractMethods(document: vscode.TextDocument, docSymbols: DocumentSymbol[]): Promise<SymbolInfo[]> {
         const symbolInfos = this.extractFunctions(document.uri, document.uri.toModulePath(), '', docSymbols);
         return symbolInfos;
     }

src/services/languages/symbolProvider.ts

@@ -135,11 +135,12 @@ export class SymbolProvider
             if (symbolTrees[0].range) {
                 // Document symbols
                 const allDocSymbols = symbolTrees as DocumentSymbol[];
-                const symbolInfos = supportedLanguage.methodExtractors
-                    .map(x => x.extractMethods(document, allDocSymbols))
-                    .flat();
-
-                return symbolInfos;
+                const methodExtractors = supportedLanguage.methodExtractors;
+                const extractedMethods = await Promise.all(
+                    methodExtractors.map(async (x) => await x.extractMethods(document, allDocSymbols))
+                );
+                const methods = extractedMethods.flat()
+                return methods;
             }
             else {
                 // Document symbols
@@ -160,11 +161,11 @@ export class SymbolProvider
             //  at index `5*i+3` - `tokenType`: will be looked up in `SemanticTokensLegend.tokenTypes`. We currently ask that `tokenType` < 65536.
             //  at index `5*i+4` - `tokenModifiers`: each set bit will be looked up in `SemanticTokensLegend.tokenModifiers`
 
-            const legends = await this.retryOnStartup<vscode.SemanticTokensLegend>(
+            let legends = (await this.retryOnStartup<vscode.SemanticTokensLegend>(
                 async () => await vscode.commands.executeCommand('vscode.provideDocumentRangeSemanticTokensLegend', document.uri),
                 value => value?.tokenTypes ? true : false,
                 document.languageId,
-            );
+            ));
             if(!legends) {
                 return tokes;
             }

src/services/languages/tokens.ts

@@ -35,7 +35,8 @@ export enum TokenType {
     punctuation = 'punctuation',
     string = 'string',
     plainKeyword = 'plainKeyword',
-    namespace = 'namespace'
+    namespace = 'namespace',
+    keyword = 'keyword'
 }
 
 export function matchTokenSequence(tokens: Token[], matchers: TokenMatcher[]): boolean {

src/views-ui/common/common.scss

@@ -105,6 +105,7 @@ ul.tree{
 .left-ellipsis{
     @extend .ellipsis;
     direction: rtl;
+    unicode-bidi: plaintext;
 }
 
 .filter-tag {

src/views/codeAnalytics/common.ts

@@ -38,13 +38,6 @@ export class HtmlHelper
 
     public static getCodeObjectLabel(funcName: string): string 
     {
-        if (funcName.includes(".")) {
-            let tokens = funcName.split(".");
-            if(tokens.length > 1){
-                funcName = `${tokens[tokens.length-2]}.${tokens[tokens.length-1]}`;
-            }
-        }
-
         return /*html*/ `
             <span class="scope">Scope:</span>
             <span class="codicon codicon-symbol-method" title="Method"></span>