feat(linter): add options for linter control

Added 3 commands for:
- Running the initialisation process for the linter
- Cleaning the linter produced files e.g. .mod
- Cleaning all diagnostics produced by the linter

Added the settings to:
- Run the initialisation of the linter upon extension activation
- Added the experimental setting of discarding the full project-wide diagnostics produced
by the initialisation process

Edited the descriptions of 2 existing settings

Added additional extension activation events on commands

Author: gnikit

CHANGELOG.md

@@ -9,6 +9,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Added
 
+- Added new settings for disabling Linter initialization and display of initialization Diagnostics
+  `fortran.linter.initialize` and `fortran.experimental.keepInitDiagnostics`
+- Added commands for Initializing, Cleaning build artefacts and Clearing the Diagnostics from the Linter
 - Added support for storing build artefacts in a separate cache directory
   ([#614](https://github.com/fortran-lang/vscode-fortran-support/issues/614))
 - Added a naive initialization for Fortran source files present in the workspace.
@@ -43,6 +46,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changed
 
+- Changed the activation events of the extension to include the `onCommand` for all register commands
 - Changed glob resolution module to `glob` from `fast-glob` due to bug #43
   ([#681](https://github.com/fortran-lang/vscode-fortran-support/issues/681))
 - Changed how Python packages are installed for unittesting for performance

package.json

@@ -52,7 +52,15 @@
   },
   "activationEvents": [
     "onLanguage:FortranFreeForm",
-    "onLanguage:FortranFixedForm"
+    "onLanguage:FortranFixedForm",
+    "onCommand:fortran.analysis.restartLanguageServer",
+    "onCommand:fortran.analysis.rescanLinter",
+    "onCommand:fortran.analysis.cleanLinterDiagnostics",
+    "onCommand:fortran.analysis.cleanLinterFiles",
+    "onCommand:fortran.analysis.initLinter",
+    "onCommand:fortran.analysis.showWhatsNew",
+    "onCommand:fortran.build.run",
+    "onCommand:fortran.build.debug"
   ],
   "main": "./dist/extension.js",
   "extensionDependencies": [
@@ -231,6 +239,12 @@
             "markdownDescription": "Compiler used for linting support.",
             "order": 0
           },
+          "fortran.linter.initialize": {
+            "type": "boolean",
+            "default": true,
+            "markdownDescription": "Attempt to initialize the linter by mock-compiling all files in the workspace.",
+            "order": 5
+          },
           "fortran.linter.compilerPath": {
             "type": "string",
             "default": "",
@@ -257,7 +271,7 @@
           "fortran.linter.modOutput": {
             "type": "string",
             "default": "",
-            "markdownDescription": "Global output directory for .mod files generated due to linting `-J<linter.modOutput>`. Can resolve internal variables with `~`, `${workspaceFolder}`, `${env}`, `${config}`, `${file}`, `${fileDirname}`, `${fileBasenameNoExtension}`.",
+            "markdownDescription": "Output directory for .mod files generated due to linting `-J<linter.modOutput>`. By default this is an internal VS Code path unique to each workspace. Can resolve internal variables with `~`, `${workspaceFolder}`, `${env}`, `${config}`, `${file}`, `${fileDirname}`, `${fileBasenameNoExtension}`.",
             "order": 40
           },
           "fortran.linter.fypp.enabled": {
@@ -307,7 +321,7 @@
               "std",
               "gfortran5"
             ],
-            "markdownDescription": "ine numbering marker format,  currently std`, `cpp` and `gfortran5` are supported, where `std` emits `#line` pragmas similar to standard tools, 'cpp' produces line directives as emitted by GNU cpp, and `gfortran5` cpp line directives with a workaround for a bug introduced in GFortran 5. Default: `cpp`.",
+            "markdownDescription": "Line numbering marker format,  currently std`, `cpp` and `gfortran5` are supported, where `std` emits `#line` pragmas similar to standard tools, 'cpp' produces line directives as emitted by GNU cpp, and `gfortran5` cpp line directives with a workaround for a bug introduced in GFortran 5. Default: `cpp`.",
             "order": 120
           },
           "fortran.linter.fypp.extraArgs": {
@@ -526,6 +540,19 @@
           }
         }
       },
+      {
+        "id": "experimental",
+        "title": "Experimental",
+        "order": 500,
+        "properties": {
+          "fortran.experimental.keepInitDiagnostics": {
+            "type": "boolean",
+            "default": true,
+            "markdownDescription": "Keep (and show) all diagnostics generated from the initialization of the Linter, not just from opened files.",
+            "order": 0
+          }
+        }
+      },
       {
         "id": "deprecated",
         "title": "Deprecated Options",
@@ -581,7 +608,22 @@
       {
         "category": "Fortran",
         "command": "fortran.analysis.rescanLinter",
-        "title": "Rescan Linter paths"
+        "title": "Rescan Linter Include paths"
+      },
+      {
+        "category": "Fortran",
+        "command": "fortran.analysis.initLinter",
+        "title": "Initialize Fortran Linter"
+      },
+      {
+        "category": "Fortran",
+        "command": "fortran.analysis.cleanLinterFiles",
+        "title": "Clean Linter generated files"
+      },
+      {
+        "category": "Fortran",
+        "command": "fortran.analysis.cleanLinterDiagnostics",
+        "title": "Clean All Linter Diagnostics"
       },
       {
         "category": "Fortran",
@@ -615,6 +657,24 @@
           "title": "Rescan Linter paths",
           "when": "!virtualWorkspace && shellExecutionSupported"
         },
+        {
+          "category": "Fortran",
+          "command": "fortran.analysis.initLinter",
+          "title": "Initialize Fortran Linter",
+          "when": "!virtualWorkspace && shellExecutionSupported"
+        },
+        {
+          "category": "Fortran",
+          "command": "fortran.analysis.cleanLinterFiles",
+          "title": "Clean Linter generated files",
+          "when": "!virtualWorkspace && shellExecutionSupported"
+        },
+        {
+          "category": "Fortran",
+          "command": "fortran.analysis.cleanLinterDiagnostics",
+          "title": "Clean All Linter Diagnostics",
+          "when": "!virtualWorkspace && shellExecutionSupported"
+        },
         {
           "category": "Fortran",
           "command": "fortran.analysis.showWhatsNew",

src/extension.ts

@@ -47,7 +47,8 @@ export async function activate(context: vscode.ExtensionContext) {
     })
   );
   // Linter is always activated but will only lint if compiler !== Disabled
-  const linter = new FortranLintingProvider(logger, context.storageUri.fsPath);
+  const linterCache = path.join(context.storageUri.fsPath);
+  const linter = new FortranLintingProvider(logger, linterCache);
   linter.activate(context);
   vscode.languages.registerCodeActionsProvider(FortranDocumentSelector(), linter);
 

src/features/commands.ts

@@ -4,6 +4,9 @@
 
 export const RestartLS = 'fortran.analysis.restartLanguageServer';
 export const RescanLint = 'fortran.analysis.rescanLinter';
+export const CleanLintDiagnostics = 'fortran.analysis.cleanLinterDiagnostics';
+export const CleanLintFiles = 'fortran.analysis.cleanLinterFiles';
+export const InitLint = 'fortran.analysis.initLinter';
 export const WhatsNew = 'fortran.analysis.showWhatsNew';
 export const BuildRun = 'fortran.build.run';
 export const BuildDebug = 'fortran.build.debug';

src/features/linter-provider.ts

@@ -6,6 +6,7 @@ import * as cp from 'child_process';
 import which from 'which';
 import * as semver from 'semver';
 import * as vscode from 'vscode';
+import { glob } from 'glob';
 
 import * as pkg from '../../package.json';
 import { Logger } from '../services/logging';
@@ -20,7 +21,14 @@ import {
   shellTask,
 } from '../lib/tools';
 import { arraysEqual } from '../lib/helper';
-import { BuildDebug, BuildRun, RescanLint } from './commands';
+import {
+  BuildDebug,
+  BuildRun,
+  InitLint,
+  CleanLintFiles,
+  RescanLint,
+  CleanLintDiagnostics,
+} from './commands';
 import { GlobPaths } from '../lib/glob-paths';
 
 const GNU = new GNULinter();
@@ -52,6 +60,12 @@ export class LinterSettings {
     const compiler = this.config.get<string>('linter.compiler');
     return compiler;
   }
+  public get initialize() {
+    return this.config.get<boolean>('linter.initialize');
+  }
+  public get keepInitDiagnostics() {
+    return this.config.get<boolean>('experimental.keepInitDiagnostics');
+  }
   public get compilerPath(): string {
     return this.config.get<string>('linter.compilerPath');
   }
@@ -148,7 +162,7 @@ export class LinterSettings {
 }
 
 export class FortranLintingProvider {
-  constructor(private logger: Logger = new Logger(), private storageUI: string = '') {
+  constructor(private logger: Logger = new Logger(), private storageUI: string = undefined) {
     // Register the Linter provider
     this.fortranDiagnostics = vscode.languages.createDiagnosticCollection('Fortran');
     this.settings = new LinterSettings(this.logger);
@@ -158,6 +172,7 @@ export class FortranLintingProvider {
   private pathCache = new Map<string, GlobPaths>();
   private settings: LinterSettings;
   private linter: GNULinter | GNUModernLinter | IntelLinter | NAGLinter;
+  private disposables: vscode.Disposable[];
 
   public provideCodeActions(
     document: vscode.TextDocument,
@@ -173,6 +188,17 @@ export class FortranLintingProvider {
     context.subscriptions.push(
       vscode.commands.registerCommand(RescanLint, this.rescanLinter, this)
     );
+    context.subscriptions.push(vscode.commands.registerCommand(InitLint, this.initialize, this));
+    context.subscriptions.push(vscode.commands.registerCommand(CleanLintFiles, this.clean, this));
+    context.subscriptions.push(
+      vscode.commands.registerCommand(
+        CleanLintDiagnostics,
+        () => {
+          this.fortranDiagnostics.clear();
+        },
+        this
+      )
+    );
     context.subscriptions.push(
       vscode.commands.registerTextEditorCommand(
         BuildRun,
@@ -192,38 +218,39 @@ export class FortranLintingProvider {
       )
     );
 
-    // Run the linter on every FreeForm and FixedForm Fortran file detected
-    // in the workspace. Run this before registering the linter as an
-    // Open event handler to prevent from Diagnostics being served for the whole
-    // workspace
-    await this.initialize();
-
-    vscode.workspace.onDidOpenTextDocument(this.doLint, this, context.subscriptions);
+    vscode.workspace.onDidOpenTextDocument(this.doLint, this, this.disposables);
     vscode.workspace.onDidCloseTextDocument(
-      textDocument => {
-        this.fortranDiagnostics.delete(textDocument.uri);
+      doc => {
+        this.fortranDiagnostics.delete(doc.uri);
       },
-      null,
-      context.subscriptions
+      this,
+      this.disposables
     );
 
-    vscode.workspace.onDidSaveTextDocument(this.doLint, this);
-
-    // Run gfortran in all open fortran files
+    vscode.workspace.onDidSaveTextDocument(this.doLint, this, this.disposables);
+    // Run the linter for all open documents i.e. docs loaded in memory
     vscode.workspace.textDocuments.forEach(this.doLint, this);
 
     // Update settings on Configuration change
     vscode.workspace.onDidChangeConfiguration(e => {
       this.settings.update(e);
-    });
+    }, this.disposables);
+
+    if (this.settings.initialize) this.initialize();
   }
 
   public dispose(): void {
     this.fortranDiagnostics.clear();
     this.fortranDiagnostics.dispose();
+    this.disposables.forEach(d => d.dispose());
   }
 
-  private async doLint(document: vscode.TextDocument) {
+  /**
+   * Lint a document using the specified linter options
+   * @param document TextDocument to lint
+   * @returns An array of vscode.Diagnostic[]
+   */
+  private async doLint(document: vscode.TextDocument): Promise<vscode.Diagnostic[]> | undefined {
     // Only lint if a compiler is specified
     if (!this.settings.enabled) return;
     // Only lint Fortran (free, fixed) format files
@@ -239,6 +266,9 @@ export class FortranLintingProvider {
     return diagnostics;
   }
 
+  /**
+   * Scan the workspace for Fortran files and lint them
+   */
   private async initialize() {
     const files = await this.getFiles();
     const opts = {
@@ -258,12 +288,16 @@ export class FortranLintingProvider {
           message: `file ${i}/${files.length}`,
         });
         try {
-          this.doBuild(await vscode.workspace.openTextDocument(file));
+          const doc = await vscode.workspace.openTextDocument(file);
+          this.doLint(doc);
         } catch (error) {
           continue;
         }
       }
     });
+    // Clear the diagnostics from the Problems console. FYI The textdocuments
+    // are still open in memory
+    if (!this.settings.keepInitDiagnostics) this.fortranDiagnostics.clear();
   }
 
   private async getFiles() {
@@ -290,6 +324,18 @@ export class FortranLintingProvider {
     return deps;
   }
 
+  /**
+   * Clean any build artifacts produced by the linter e.g. .mod, .smod files
+   */
+  private async clean() {
+    if (!this.storageUI) return;
+    const cacheDir = this.storageUI;
+    const files = glob.sync(cacheDir + '/**/*.{mod,smod,o}');
+    files.forEach(file => {
+      fs.promises.rm(file);
+    });
+  }
+
   private async doBuild(document: vscode.TextDocument): Promise<string> | undefined {
     this.linter = this.getLinter(this.settings.compiler);
     const command = this.settings.compilerExe;