Factorize shareable logic

Author: eliericha

integration/vscode/ada/src/AdaCodeLensProvider.ts

@@ -10,16 +10,16 @@ import {
     TextDocument,
     commands,
 } from 'vscode';
-import { getMains } from './helpers';
 import { CMD_BUILD_AND_DEBUG_MAIN, CMD_BUILD_AND_RUN_MAIN } from './commands';
+import { getMains, getSymbols } from './helpers';
 
 export class AdaCodeLensProvider implements CodeLensProvider {
     static readonly ENABLE_SPARK_CODELENS = false;
 
     onDidChangeCodeLenses?: Event<void> | undefined;
     provideCodeLenses(
         document: TextDocument,
-        _token?: CancellationToken
+        token?: CancellationToken
     ): ProviderResult<CodeLens[]> {
         const symbols = commands.executeCommand<DocumentSymbol[]>(
             'vscode.executeDocumentSymbolProvider',
@@ -70,33 +70,14 @@ export class AdaCodeLensProvider implements CodeLensProvider {
              * This is tentative deactivated code in preparation of SPARK support.
              */
             res2 = symbols.then<CodeLens[]>((symbols) => {
-                // Create a named reduce function to implement a recursive visit of symbols
-                const reduce = (acc: DocumentSymbol[], cur: DocumentSymbol) => {
-                    if (_token?.isCancellationRequested) {
-                        throw new CancellationError();
-                    }
-                    if (cur.kind == SymbolKind.Function) {
-                        // Include functions in the accumulated result
-                        acc.push(cur);
-                    }
+                const symbolKinds = [SymbolKind.Function];
+                const recurseInto = [SymbolKind.Module, SymbolKind.Package, SymbolKind.Function];
 
-                    // Search for Functions among the children of these symbol kinds
-                    if (
-                        [SymbolKind.Module, SymbolKind.Package, SymbolKind.Function].includes(
-                            cur.kind
-                        )
-                    ) {
-                        cur.children.reduce(reduce, acc);
-                    }
-
-                    return acc;
-                };
-
-                // Collect functions recursively
-                const functions = symbols.reduce(reduce, []);
+                // Create a named reduce function to implement a recursive visit of symbols
+                const functions = getSymbols(symbols, symbolKinds, recurseInto, token);
 
                 return functions.map((f) => {
-                    if (_token?.isCancellationRequested) {
+                    if (token?.isCancellationRequested) {
                         throw new CancellationError();
                     }
                     // TODO make SPARK codelenses conditional to the availability of SPARK on PATH

integration/vscode/ada/src/helpers.ts

@@ -21,6 +21,7 @@ import * as vscode from 'vscode';
 import { ExecuteCommandRequest, LanguageClient } from 'vscode-languageclient/node';
 import winston from 'winston';
 import { adaExtState, logger } from './extension';
+import { DocumentSymbol, SymbolKind, CancellationToken, CancellationError } from 'vscode';
 
 /**
  * Substitue any variable reference present in the given string. VS Code
@@ -389,3 +390,47 @@ export async function findAdaMain(mainPath: string): Promise<AdaMain | undefined
     );
     return adaMain;
 }
+/**
+ * Starting from an array of symbols {@link rootSymbols} (usually obtained for a
+ * document using the vscode.executeDocumentSymbolProvider command), iterate the
+ * symbols recursively and return an array of the symbols of a given set of
+ * kinds {@link symbolKinds}.
+ *
+ * Recursion is control by another set of symbols kinds {@link recurseInto}.
+ * Only the children of these kinds of symbols are recursed into.
+ *
+ * @param rootSymbols - the array of symbols to start from
+ * @param symbolKinds - kinds of symbols to include in the result
+ * @param recurseInto - kinds of symbols to recurse into
+ * @param token - a cancellation token to abort the search
+ * @returns an array of {@link DocumentSymbol}s of the kinds requested in symbolKinds.
+ */
+
+export function getSymbols(
+    rootSymbols: DocumentSymbol[],
+    symbolKinds: SymbolKind[],
+    recurseInto: SymbolKind[] = [SymbolKind.Module, SymbolKind.Package, SymbolKind.Function],
+    token?: CancellationToken
+): DocumentSymbol[] {
+    const reduce = (acc: DocumentSymbol[], cur: DocumentSymbol) => {
+        if (token?.isCancellationRequested) {
+            throw new CancellationError();
+        }
+        if (symbolKinds.includes(cur.kind)) {
+            // Include targeted symbol kinds in the result
+            acc.push(cur);
+        }
+
+        // Recurse into symbols of the specified kinds
+        if (recurseInto.includes(cur.kind)) {
+            cur.children.reduce(reduce, acc);
+        }
+
+        return acc;
+    };
+
+    // Collect symbols recursively
+    const allSymbols = rootSymbols.reduce(reduce, []);
+
+    return allSymbols;
+}

integration/vscode/ada/src/taskProviders.ts

@@ -18,8 +18,9 @@
 import assert from 'assert';
 import commandExists from 'command-exists';
 import * as vscode from 'vscode';
-import { adaExtState } from './extension';
-import { AdaMain, getAdaMains, getProjectFile } from './helpers';
+import { adaExtState, logger } from './extension';
+import { AdaMain, getAdaMains, getProjectFile, getSymbols } from './helpers';
+import { SymbolKind } from 'vscode';
 
 export const ADA_TASK_TYPE = 'ada';
 
@@ -376,24 +377,10 @@ export async function getEnclosingSymbol(
         );
 
         // Then filter them according to the specified kinds
-        const filtered_symbols: vscode.DocumentSymbol[] = [];
-
-        const getAllSymbols = (symbols: vscode.DocumentSymbol[]) => {
-            let sym;
-            for (sym of symbols) {
-                if (kinds.includes(sym.kind)) {
-                    filtered_symbols.push(sym);
-                }
-                if (
-                    sym.kind == vscode.SymbolKind.Function ||
-                    sym.kind == vscode.SymbolKind.Module
-                ) {
-                    getAllSymbols(sym.children);
-                }
-            }
-        };
-
-        getAllSymbols(symbols);
+        const filtered_symbols = getSymbols(symbols, kinds, [
+            SymbolKind.Function,
+            SymbolKind.Module,
+        ]);
 
         // Finally select from the filtered symbols the smallest one containing the current line
         const scopeSymbols = filtered_symbols.filter(
@@ -413,9 +400,9 @@ export async function getEnclosingSymbol(
     return null;
 }
 
-const getSelectedRegion = (editor: vscode.TextEditor | undefined): string => {
+export const getSelectedRegion = (editor: vscode.TextEditor | undefined): string => {
     if (editor) {
-        const selection = editor.selections[0];
+        const selection = editor.selection;
         //  Line numbers start at 0 in VS Code, and at 1 in GNAT
         return (selection.start.line + 1).toString() + ':' + (selection.end.line + 1).toString();
     } else {