add document symbols provider

Author: krvajal

src/features/completion-provider.ts

@@ -4,6 +4,7 @@ import { CancellationToken, TextDocument, Position, Hover } from "vscode";
 import * as fs from 'fs';
 import * as vscode from 'vscode';
 import { isPositionInString, intrinsics, FORTRAN_KEYWORDS } from "../lib/helper";
+import { getDeclaredFunctions } from "../lib/functions";
 
 
 export class FortranCompletionProvider implements vscode.CompletionItemProvider {
@@ -54,6 +55,13 @@ export class FortranCompletionProvider implements vscode.CompletionItemProvider
                     }
                 });
             }
+            const functions = getDeclaredFunctions(document);
+            // check for available functions
+            functions.filter(fun => fun.name.startsWith(currentWord))
+            .forEach(fun =>{
+                suggestions.push(new vscode.CompletionItem(fun.name, vscode.CompletionItemKind.Function));   
+            });
+            
 
             return resolve(suggestions);
 

src/features/document-symbol-provider.ts

@@ -0,0 +1,23 @@
+
+
+import { CancellationToken, TextDocument, Position, Hover } from "vscode";
+
+import * as vscode from 'vscode';
+import { getDeclaredFunctions } from '../lib/functions'
+
+
+export class FortranDocumentSymbolProvider implements vscode.DocumentSymbolProvider {
+
+    public provideDocumentSymbols(document: TextDocument, token: CancellationToken){
+        
+        let functions = getDeclaredFunctions(document).map(fun => {
+
+            let range = new vscode.Range(fun.lineNumber, 0, fun.lineNumber, 100);
+            return new vscode.SymbolInformation(fun.name, vscode.SymbolKind.Function, range );
+        });
+
+
+        return functions;
+    }
+
+}

src/lib/functions.ts

@@ -0,0 +1,62 @@
+
+import * as vscode from 'vscode';
+
+export interface Variable {
+    name: string;
+    type?: string;
+}
+
+export interface Function {
+    name: string;
+    args: Variable[];
+    return: Variable;
+    docstr: string;
+    lineNumber: number
+}
+
+
+
+export function getDeclaredFunctions(document: vscode.TextDocument): Function[] {
+
+    let lines = document.lineCount;
+    let funs = [];
+
+    for (let i = 0; i < lines; i++) {
+        let line: vscode.TextLine = document.lineAt(i);
+        if (line.isEmptyOrWhitespace) continue;
+        let newFunc = parseFunction(line.text)
+        if(newFunc){
+            funs.push({...newFunc, lineNumber: i });
+        }
+    }
+    return funs;
+}
+
+export const parseFunction = (line: string) => {
+
+    const functionRegEx = /function\s*([a-zA-Z][a-zA-Z0-9_]*)\s*\((\s*[a-zA-z][a-zA-z0-9_,\s]*)*\s*\)/g
+    if (line.match(functionRegEx)) {
+
+        let [name, argsstr] = functionRegEx.exec(line).slice(1, 3);
+        let args = (argsstr)? parseArgs(argsstr): [];
+        return {
+            name: name,
+            args: args,
+            return: null
+        };
+    }
+}
+
+export const parseArgs = (argsstr: string) => {
+    let args = argsstr.trim().split(',');
+    let variables: Variable[] = args.filter(name => validVariableName(name))
+        .map(name => {
+            return { name: name };
+        });
+    return variables;
+}
+
+export const validVariableName = (name: string) => {
+    return name.trim().match(/^[a-zA-Z_][a-zA-Z0-9_]*$/) !== null;
+}
+

test/extension.test.ts

@@ -31,7 +31,7 @@ suite("Extension Tests", () => {
         });
     };   
 
-    test("load doc files", () => {
+    test.skip("load doc files", () => {
       intrinsics.map( keyword => saveKeywordToJson(keyword));
     });
 });

test/helper.test.ts

@@ -0,0 +1,46 @@
+//
+// Note: This example test is leveraging the Mocha test framework.
+// Please refer to their documentation on https://mochajs.org/ for help.
+//
+
+// The module 'assert' provides assertion methods from node
+import * as assert from 'assert';
+import * as fs from 'fs';
+import { validVariableName, parseFunction, parseArgs } from '../src/lib/functions';
+
+suite("function helper test", () => {
+
+    test("validVariableName does not allow variables starting with number", () => {
+        assert.equal(false, validVariableName("1as"));
+    });
+    test("validVariableName returns true  with correct variable", () => {
+        assert.equal(true, validVariableName("matA"));
+    });
+    test("validVariableName returns true for variables starting with uppercase", () => {
+        assert.equal(true, validVariableName("MatA"));
+    });
+    test("validVariableName return true for variable starting with _", () => {
+        assert.equal(true, validVariableName("_matA"));
+    });
+    test("parseFuntion return undefined on empty line", () => {
+        assert.equal(undefined, parseFunction(""));
+    });
+    test("parseFuntion return undefined if function keyword is missing", () => {
+        assert.equal(undefined, parseFunction("hello"));
+    });
+    test("parseFuntion return correct function name", () => {
+        assert.equal("hello", parseFunction("function hello()").name);
+    });
+
+    test("parseFuntion return correct number of args", () => {
+        assert.equal(2, parseFunction("function hello( a, b)").args.length);
+    });
+    test("parseArgs return the correct number of args", () => {
+        assert.equal(2, parseArgs("a,b").length);
+    })
+    test("parseArgs handle spaces well", () => {
+        assert.equal(2, parseArgs(" a, b").length);
+    });
+});
+
+