Merge branch 'topic/gnatmetric-int' into 'master'

Add GNATmetric integration using CodeLenses

See merge request eng/ide/ada_language_server!2236

Author: AnthonyLeonardoGracio

CHANGELOG.md

@@ -11,6 +11,7 @@ section below it for the last release. -->
 * Highlight `finally` keyword (from Ada extension) with semantic tokens
 * Prompt the user to restart the Ada Language Server when the workspace `.als.json` configuration file is modified
 * Two color themes **GNAT Studio Light** and **GNAT Studio Dark**
+* Add a predefined task to compute file metrics and display them automatically via CodeLenses
 
 ## 2026.1.202601121
 

doc/media/gnatmetric-thresholds.png

@@ -96,6 +96,7 @@ Settings taken into account only from the Ada & SPARK VS Code extension:
 
 * [showNotificationsOnErrors](#shownotificationsonerrors)
 * [trace.server](#traceserver)
+* [metricThresholds](#metricthresholds)
 
 Settings understood by the Ada Language Server itself, independently from the LSP client:
 
@@ -147,6 +148,28 @@ On the server side this option does not trigger any additional logging.
 
 An equivalent setting `gpr.trace.server` exists for tracing the communcation between VS Code and the GPR language server.
 
+### metricThresholds
+
+Configurable thresholds for metrics provided by `gnatmetric`. Each key is a metric name (e.g., `cyclomatic_complexity`, `code_lines`), and the value is an object with optional `warn` and `error` numeric thresholds.
+Metric names can be retrieved from the XML metric files generated by `gnatmetric`, which by default are located under the project's object directory (`.metrics.xml` files).
+
+Below is an example configuration for setting metric thresholds to highlight subprograms with high cyclomatic complexity:
+
+```json
+{
+   "ada.metricThresholds":
+   {
+      "cyclomatic_complexity":
+      {
+         "warn": 10,
+         "error": 20
+      }
+   }
+}
+```
+
+If not set, no thresholds will be applied.
+
 ### projectFile
 
 You can configure the GNAT Project File via the `projectFile` key.

doc/media/gnatmetric-vscode.gif

@@ -27,6 +27,7 @@ This extension **does not include a compiler nor additional tools**. Nonetheless
 | | Code Coverage       | ✅ |
 | **GNAT SAS** | | |
 | | Static Analysis     |       ✅            |
+| | Metrics             |       ✅            |
 | **SPARK** | | |
 | | Formal Proof        |       ✅          |
 
@@ -314,6 +315,18 @@ The GNATtest integration in VS Code also supports running tests in coverage mode
 
 Integrating the steps of source instrumentation and test harness build into the test execution workflow allows for a quick feedback loop: run a test, observe results and coverage, edit the test or the tested code, repeat... In this context invoking the VS Code commands `Test: Rerun Last Run` and `Test: Rerun Last Run with Coverage` with their respective keyboard shortcuts can be valuable.
 
+## GNAT Metrics Support
+
+The extension provides a predefined task called `Compute metrics for current file`, which runs `gnatmetric` and displays file metrics directly in the editor using CodeLenses.
+
+![GNAT Metrics CodeLenses](media/gnatmetric-vscode.gif)
+
+By default, the displayed metrics include code complexity and lines of code. You can customize which metrics are shown by adjusting the command-line options for `gnatmetric` in the task configuration.
+
+You can configure thresholds for specific metrics to highlight when they are exceeded via the `ada.metricThresholds` [VS Code setting](./settings.md#metricthresholds). The extension will display warning or error diagnostics for each violation, and the corresponding CodeLenses will show warning or error icons as appropriate.
+
+![GNAT Metrics Thresholds](media/gnatmetric-thresholds.png)
+
 ## Cross and Embedded Support
 
 This section provides some guidance to work on cross or embedded projects. It assumes
@@ -489,15 +502,15 @@ The VS Code extension has a few limitations and some differences compared to [GN
 * **Indentation/formatting**: it does not support automatic indentation when adding a newline and range/document
 formatting might no succeed on incomplete/illegal code.
 
-* **Tooling support**: we currently provide support for some _SPARK_, _GNATtest_, _GNATcoverage_, _GNAT SAS_ and _GNATemulator_ [Tasks](#tasks), but some workflows may not be supported yet.
+* **Tooling support**: we currently provide support for some _SPARK_, _GNATtest_, _GNATcoverage_, _GNAT SAS_, _GNATmetric_ and _GNATemulator_ [Tasks](#tasks), but some workflows may not be supported yet.
 
 * **Alire support**: if the root folder contains an `alire.toml` file and
   there is `alr` executable in the `PATH`, then the language server fetches
   the project's search path, environment variables and the project's file
   name from the crate description. [Tasks](#tasks) are also automatically
   invoked with Alire in this case.
 
-* **Project support**: there is no `Scenario` view: users should configure scenarios via the _ada.scenarioVariables* setting (see the settings list available [here](./settings.md)). Saving the settings file after changing the values will automatically reload the project and update the
+* **Project support**: there is no `Scenario` view: users should configure scenarios via the `ada.scenarioVariables` setting (see the settings list available [here](./settings.md)). Saving the settings file after changing the values will automatically reload the project and update the
 predefined tasks to take into account the new scenario values.
 
   Source directories from imported projects should be added in a [workspace file](https://code.visualstudio.com/docs/editor/workspaces#_multiroot-workspaces). If you already have a workspace file, the extension will propose you to automatically add all the source directories coming from imported projects to your workspace automatically at startup.

doc/settings.md

@@ -564,6 +564,12 @@
                         ],
                         "default": null,
                         "markdownDescription": "Enable editing Ada comments to update references to an entity when it is being renamed.\n\nIf not set in VS Code, this setting takes its value from the [`.als.json`](https://github.com/AdaCore/ada_language_server/blob/master/doc/settings.md) file at the root of the workspace, if that file exists. Otherwise it defaults to `false`."
+                    },
+                    "ada.metricThresholds": {
+                        "scope": "window",
+                        "type": "object",
+                        "default": null,
+                        "markdownDescription": "Configurable thresholds for metrics provided by `gnatmetric`. Each key is a metric name (e.g., `cyclomatic_complexity`, `code_lines`), and the value is an object with optional 'warn' and 'error' numeric thresholds.\nMetric names can be retrieved from the XML metric files generated by `gnatmetric`, which by default are located under the project's object directory (`.metrics.xml` files).\n\nIf not set, no thresholds will be applied."
                     }
                 }
             },
@@ -1616,4 +1622,4 @@
         "ws": "^8.18.0",
         "yaml": "^2.8.0"
     }
-}
+}

doc/vscode-ug.md

@@ -139,6 +139,12 @@
             "type": "integer",
             "default": 10,
             "description": "Controls the maximum number of trace files preserved in the ALS log directory (which defaults to `~/.als`). When this threshold is reached, old trace files get deleted automatically. The default number of preserved trace files is `10`."
+        },
+        "metricThresholds": {
+            "scope": "window",
+            "type": "object",
+            "default": null,
+            "markdownDescription": "Configurable thresholds for metrics provided by `gnatmetric`. Each key is a metric name (e.g., `cyclomatic_complexity`, `code_lines`), and the value is an object with optional 'warn' and 'error' numeric thresholds.\nMetric names can be retrieved from the XML metric files generated by `gnatmetric`, which by default are located under the project's object directory (`.metrics.xml` files).\n\nIf not set, no thresholds will be applied."
         }
     },
     "additionalProperties": false

integration/vscode/ada/package.json

@@ -19,123 +19,110 @@ import {
     CMD_SPARK_PROVE_SUBP,
 } from './constants';
 import { envHasExec, getSymbols } from './helpers';
+import { findMetricsXmlForSource, formatMetric, parseMetricsXml } from './metricsUtils';
+import * as vscode from 'vscode';
 import { adaExtState } from './extension';
 
 export class AdaCodeLensProvider implements CodeLensProvider {
-    onDidChangeCodeLenses?: Event<void> | undefined;
-    provideCodeLenses(
+    private emitter = new vscode.EventEmitter<void>();
+    readonly onDidChangeCodeLenses = this.emitter.event;
+
+    async provideCodeLenses(
         document: TextDocument,
         token?: CancellationToken,
-    ): ProviderResult<CodeLens[]> {
-        const symbols = commands.executeCommand<DocumentSymbol[] | undefined>(
+    ): Promise<CodeLens[]> {
+        const symbols = await commands.executeCommand<DocumentSymbol[] | undefined>(
             'vscode.executeDocumentSymbolProvider',
             document.uri,
         );
 
-        /**
-         * For main procedures, provide Run and Debug CodeLenses.
-         */
-        const res1 = adaExtState.getTargetPrefix().then((targetPrefix) => {
-            return adaExtState.getMains().then((mains) => {
-                if (
-                    mains.some(
-                        (m) =>
-                            // Here we go through the Uri class to benefit from the normalization
-                            // of path casing on Windows. See Uri.fsPath documentation.
-                            Uri.file(m).fsPath == document.uri.fsPath,
-                    )
-                ) {
-                    // It's a main file, so let's offer Run and Debug actions on the main subprogram
-                    return symbols.then((symbols) => {
-                        if (!symbols) {
-                            return [];
-                        }
+        // For main procedures, provide Run and Debug CodeLenses.
+        const targetPrefix = await adaExtState.getTargetPrefix();
+        const mains = await adaExtState.getMains();
+        let codeLenses: CodeLens[] = [];
+        if (mains.some((m) => Uri.file(m).fsPath === document.uri.fsPath)) {
+            if (symbols) {
+                const functions = symbols.filter((s) => s.kind === SymbolKind.Function);
+                if (functions.length > 0) {
+                    codeLenses = [
+                        new CodeLens(functions[0].range, {
+                            command: CMD_BUILD_AND_RUN_MAIN,
+                            title: '$(run) Run',
+                            arguments: [document.uri],
+                        }),
+                        new CodeLens(functions[0].range, {
+                            command: CMD_BUILD_AND_DEBUG_MAIN,
+                            title: '$(debug-alt-small) Debug',
+                            arguments: [document.uri],
+                        }),
+                    ];
+                    if (targetPrefix && envHasExec(targetPrefix + '-gnatemu')) {
+                        codeLenses = codeLenses.concat([
+                            new CodeLens(functions[0].range, {
+                                command: CMD_BUILD_AND_RUN_GNATEMULATOR,
+                                title: '$(run) Run with GNATemulator',
+                                arguments: [document.uri],
+                            }),
+                            new CodeLens(functions[0].range, {
+                                command: CMD_BUILD_AND_DEBUG_GNATEMULATOR,
+                                title: '$(debug-alt-small) Debug with GNATemulator',
+                                arguments: [document.uri],
+                            }),
+                        ]);
+                    }
+                }
+            }
+        }
 
-                        const functions = symbols.filter((s) => s.kind == SymbolKind.Function);
-                        if (functions.length > 0) {
-                            /**
-                             * We choose to provide the CodeLenses on the first
-                             * subprogram of the file. It may be possible that the
-                             * main subprogram is not the first one, but that's an
-                             * unlikely scenario that we choose not to handle for
-                             * the moment.
-                             */
-                            let codeLenses = [
-                                new CodeLens(functions[0].range, {
-                                    command: CMD_BUILD_AND_RUN_MAIN,
-                                    title: '$(run) Run',
-                                    arguments: [document.uri],
-                                }),
-                                new CodeLens(functions[0].range, {
-                                    command: CMD_BUILD_AND_DEBUG_MAIN,
-                                    title: '$(debug-alt-small) Debug',
-                                    arguments: [document.uri],
+        // --- Metrics CodeLens ---
+        const objectDir = await adaExtState.getObjectDir();
+        const metricsXml = findMetricsXmlForSource(document.uri.fsPath, objectDir);
+        if (metricsXml) {
+            const parsed = await parseMetricsXml(metricsXml);
+            if (parsed && Array.isArray(parsed.units)) {
+                const { units, displayNames } = parsed;
+                for (const unit of units) {
+                    if (unit.sloc) {
+                        const metrics: string[] = [];
+                        for (const [key, value] of Object.entries(unit.metrics)) {
+                            const label = displayNames[key] || key;
+                            metrics.push(formatMetric(key, label, Number(value)));
+                        }
+                        if (metrics.length > 0) {
+                            const summary = `$(graph) Metrics: ${metrics.join(', ')}`;
+                            codeLenses.push(
+                                new CodeLens(new vscode.Range(unit.sloc, unit.sloc), {
+                                    title: summary,
+                                    command: '',
                                 }),
-                            ];
-
-                            // It's not a native project: provide a 'Run with GNATemulator' CodeLens
-                            // if GNATemulator for the given target is present in the user's env.
-                            if (targetPrefix && envHasExec(targetPrefix + '-gnatemu')) {
-                                codeLenses = codeLenses.concat([
-                                    new CodeLens(functions[0].range, {
-                                        command: CMD_BUILD_AND_RUN_GNATEMULATOR,
-                                        title: '$(run) Run with GNATemulator',
-                                        arguments: [document.uri],
-                                    }),
-                                    new CodeLens(functions[0].range, {
-                                        command: CMD_BUILD_AND_DEBUG_GNATEMULATOR,
-                                        title: '$(debug-alt-small) Debug with GNATemulator',
-                                        arguments: [document.uri],
-                                    }),
-                                ]);
-                            }
-
-                            return codeLenses;
-                        } else {
-                            return [];
+                            );
                         }
-                    });
-                } else {
-                    return [];
+                    }
                 }
-            });
-        });
+            }
+        }
 
-        let res2;
+        // SPARK CodeLenses (if gnatprove is available)
+        let sparkLenses: CodeLens[] = [];
         if (envHasExec('gnatprove')) {
-            /**
-             * This is tentative deactivated code in preparation of SPARK support.
-             */
-            res2 = symbols.then<CodeLens[]>((symbols) => {
-                if (!symbols) {
-                    return [];
-                }
-
+            if (symbols) {
                 const symbolKinds = [SymbolKind.Function];
                 const recurseInto = [SymbolKind.Module, SymbolKind.Package, SymbolKind.Function];
-
-                // Create a named reduce function to implement a recursive visit of symbols
                 const functions = getSymbols(symbols, symbolKinds, recurseInto, token);
-
-                return functions.map((f) => {
+                sparkLenses = functions.map((f) => {
                     if (token?.isCancellationRequested) {
                         throw new CancellationError();
                     }
-
                     return new CodeLens(f.selectionRange, {
                         title: '$(check) Prove',
                         command: CMD_SPARK_PROVE_SUBP,
                         arguments: [document.uri, f.selectionRange],
                     });
                 });
-            });
-        } else {
-            res2 = Promise.resolve([]);
+            }
         }
 
-        return Promise.all([res1, res2]).then((results) => {
-            return results[0].concat(results[1]);
-        });
+        return codeLenses.concat(sparkLenses);
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     resolveCodeLens?(codeLens: CodeLens, _token: CancellationToken): ProviderResult<CodeLens> {
@@ -145,4 +132,8 @@ export class AdaCodeLensProvider implements CodeLensProvider {
             throw new Error(`Cannot resolve CodeLens`);
         }
     }
+
+    refresh() {
+        this.emitter.fire();
+    }
 }