Merge pull request #625 from fortran-lang/gnikit/issue523

Author: gnikit

CHANGELOG.md

@@ -9,6 +9,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Added
 
+- Added support for enhanced `gfotran` v11+ diagnostics using `-fdiagnostics-plain-output`
+  ([#523](https://github.com/fortran-lang/vscode-fortran-support/issues/523))
 - Added language icons for Free and Fixed form Fortran
   ([#612](https://github.com/fortran-lang/vscode-fortran-support/issues/612))
 - Added capability for linter options to update automatically when settings change

package-lock.json

@@ -616,6 +616,7 @@
     "@types/glob": "^7.2.0",
     "@types/mocha": "^9.1.0",
     "@types/node": "^16.11.39",
+    "@types/semver": "^7.3.12",
     "@types/vscode": "^1.63.0",
     "@types/which": "^2.0.1",
     "@typescript-eslint/eslint-plugin": "^5.33.1",
@@ -645,6 +646,7 @@
   "dependencies": {
     "fast-glob": "^3.2.11",
     "glob": "^8.0.3",
+    "semver": "^7.3.7",
     "vscode-languageclient": "^8.0.2",
     "which": "^2.0.2"
   }

package.json

@@ -3,8 +3,9 @@
 import * as path from 'path';
 import * as cp from 'child_process';
 import which from 'which';
-
+import * as semver from 'semver';
 import * as vscode from 'vscode';
+
 import { Logger } from '../services/logging';
 import {
   EXTENSION_ID,
@@ -19,10 +20,13 @@ import { RescanLint } from './commands';
 import { GlobPaths } from '../lib/glob-paths';
 
 export class LinterSettings {
+  private _modernGNU: boolean;
+  private _version: string;
   private config: vscode.WorkspaceConfiguration;
 
   constructor(private logger: Logger = new Logger()) {
     this.config = vscode.workspace.getConfiguration(EXTENSION_ID);
+    this.GNUVersion(this.compiler); // populates version & modernGNU
   }
   public update(event: vscode.ConfigurationChangeEvent) {
     console.log('update settings');
@@ -50,6 +54,53 @@ export class LinterSettings {
   public get modOutput(): string {
     return this.config.get<string>('linter.modOutput');
   }
+
+  // END OF API SETTINGS
+
+  /**
+   * Returns the version of the compiler and populates the internal variables
+   * `modernGNU` and `version`.
+   * @note Only supports `gfortran`
+   */
+  private GNUVersion(compiler: string): string | undefined {
+    // Only needed for gfortran's diagnostics flag
+    this.modernGNU = false;
+    if (compiler !== 'gfortran') return;
+    const child = cp.spawnSync(compiler, ['--version']);
+    if (child.error || child.status !== 0) {
+      this.logger.error(`[lint] Could not spawn ${compiler} to check version.`);
+      return;
+    }
+    // State the variables explicitly bc the TypeScript compiler on the CI
+    // seemed to optimise away the stdout and regex would return null
+    const regex = /^GNU Fortran \([\w.-]+\) (?<version>.*)$/gm;
+    const output = child.stdout.toString();
+    const match = regex.exec(output);
+    const version = match ? match.groups.version : undefined;
+    if (semver.valid(version)) {
+      this.version = version;
+      this.logger.info(`[lint] Found GNU Fortran version ${version}`);
+      this.logger.debug(`[lint] Using Modern GNU Fortran diagnostics: ${this.modernGNU}`);
+      return version;
+    } else {
+      this.logger.error(`[lint] invalid compiler version: ${version}`);
+    }
+  }
+
+  public get version(): string {
+    return this._version;
+  }
+  private set version(version: string) {
+    this._version = version;
+    this.modernGNU = semver.gte(version, '11.0.0');
+  }
+  public get modernGNU(): boolean {
+    return this._modernGNU;
+  }
+  private set modernGNU(modernGNU: boolean) {
+    this._modernGNU = modernGNU;
+  }
+
   // FYPP options
 
   public get fyppEnabled(): boolean {
@@ -365,6 +416,7 @@ export class FortranLintingProvider {
     const matches = [...msg.matchAll(regex)];
     switch (this.compiler) {
       case 'gfortran':
+        if (this.settings.modernGNU) return this.linterParserGCCPlainText(matches);
         return this.linterParserGCC(matches);
 
       case 'ifx':
@@ -419,6 +471,42 @@ export class FortranLintingProvider {
     return diagnostics;
   }
 
+  private linterParserGCCPlainText(matches: RegExpMatchArray[]): vscode.Diagnostic[] {
+    const diagnostics: vscode.Diagnostic[] = [];
+    for (const m of matches) {
+      const g = m.groups;
+      // m[0] is the entire match and then the captured groups follow
+      const lineNo: number = parseInt(g['ln']);
+      const colNo: number = parseInt(g['cn']);
+      const msgSev: string = g['sev'];
+      const msg: string = g['msg'];
+
+      const range = new vscode.Range(
+        new vscode.Position(lineNo - 1, colNo),
+        new vscode.Position(lineNo - 1, colNo)
+      );
+
+      let severity: vscode.DiagnosticSeverity;
+      switch (msgSev.toLowerCase()) {
+        case 'error':
+        case 'fatal error':
+          severity = vscode.DiagnosticSeverity.Error;
+          break;
+        case 'warning':
+          severity = vscode.DiagnosticSeverity.Warning;
+          break;
+        case 'info': // gfortran does not produce info AFAIK
+          severity = vscode.DiagnosticSeverity.Information;
+          break;
+        default:
+          severity = vscode.DiagnosticSeverity.Error;
+          break;
+      }
+      diagnostics.push(new vscode.Diagnostic(range, msg, severity));
+    }
+    return diagnostics;
+  }
+
   private linterParserIntel(matches: RegExpMatchArray[]): vscode.Diagnostic[] {
     const diagnostics: vscode.Diagnostic[] = [];
     for (const m of matches) {
@@ -529,6 +617,16 @@ export class FortranLintingProvider {
        -------------------------------------------------------------------------
        */
       case 'gfortran':
+        /**
+         -----------------------------------------------------------------------
+         COMPILER: MESSAGE ANATOMY:
+         file:line:column: Severity: msg
+         -----------------------------------------------------------------------
+         see https://regex101.com/r/73TZQn/1
+         */
+        if (this.settings.modernGNU) {
+          return /(?<fname>(?:\w:\\)?.*):(?<ln>\d+):(?<cn>\d+): (?<sev>Error|Warning|Fatal Error): (?<msg>.*)/g;
+        }
         // see https://regex101.com/r/hZtk3f/1
         return /(?:^(?<fname>(?:\w:\\)?.*):(?<ln>\d+):(?<cn>\d+):(?:\s+.*\s+.*?\s+)(?<sev1>Error|Warning|Fatal Error):\s(?<msg1>.*)$)|(?:^(?<bin>\w+):\s*(?<sev2>\w+\s*\w*):\s*(?<msg2>.*)$)/gm;
 
@@ -574,6 +672,9 @@ export class FortranLintingProvider {
     switch (compiler) {
       case 'flang':
       case 'gfortran':
+        if (this.settings.modernGNU) {
+          return ['-fsyntax-only', '-cpp', '-fdiagnostics-plain-output'];
+        }
         return ['-fsyntax-only', '-cpp', '-fdiagnostics-show-option'];
 
       // ifort theoretically supports fsyntax-only too but I had trouble

src/features/linter-provider.ts

@@ -122,6 +122,7 @@ suite('fypp Linter integration', () => {
 suite('GNU (gfortran) lint single', () => {
   const linter = new FortranLintingProvider();
   linter['compiler'] = 'gfortran';
+  linter['settings']['modernGNU'] = false;
   const msg = `
 C:\\Some\\random\\path\\sample.f90:4:18:
 
@@ -164,6 +165,7 @@ Error: Missing actual argument for argument ‘a’ at (1)
 suite('GNU (gfortran) lint multiple', () => {
   const linter = new FortranLintingProvider();
   linter['compiler'] = 'gfortran';
+  linter['settings']['modernGNU'] = false;
   const msg = `
 /fetch/main/FETCH.F90:1629:24:
 
@@ -236,6 +238,7 @@ f951: some warnings being treated as errors
 suite('GNU (gfortran) lint preprocessor', () => {
   const linter = new FortranLintingProvider();
   linter['compiler'] = 'gfortran';
+  linter['settings']['modernGNU'] = false;
   const msg = `
 gfortran: fatal error: cannot execute '/usr/lib/gcc/x86_64-linux-gnu/9/f951': execv: Argument list too long\ncompilation terminated.
 `;
@@ -277,6 +280,7 @@ gfortran: fatal error: cannot execute '/usr/lib/gcc/x86_64-linux-gnu/9/f951': ex
 suite('GNU (gfortran) lint preprocessor multiple', () => {
   const linter = new FortranLintingProvider();
   linter['compiler'] = 'gfortran';
+  linter['settings']['modernGNU'] = false;
   const msg = `
 f951: Warning: Nonexistent include directory '/Code/TypeScript/vscode-fortran-support/test/fortran/include' [-Wmissing-include-dirs]
 /Code/TypeScript/vscode-fortran-support/test/fortran/sample.f90:4:18:
@@ -341,6 +345,131 @@ Error: Missing actual argument for argument 'a' at (1)
     deepStrictEqual(matches, ref);
   });
 });
+suite('GNU (gfortran v11+) lint single plain output', () => {
+  const linter = new FortranLintingProvider();
+  linter['compiler'] = 'gfortran';
+  linter['settings']['modernGNU'] = true;
+  const msg = `err-mod.f90:3:17: Error: (1)`;
+  suite('REGEX matches', () => {
+    const regex = linter['getCompilerREGEX'](linter['compiler']);
+    const matches = [...msg.matchAll(regex)];
+    const g = matches[0].groups;
+    test('REGEX: filename', () => {
+      strictEqual(g?.['fname'], 'err-mod.f90');
+    });
+    test('REGEX: line number', () => {
+      strictEqual(g?.['ln'], '3');
+    });
+    test('REGEX: column number', () => {
+      strictEqual(g?.['cn'], '17');
+    });
+    test('REGEX: severity <sev>', () => {
+      strictEqual(g?.['sev'], 'Error');
+    });
+    test('REGEX: message <msg>', () => {
+      strictEqual(g?.['msg'], '(1)');
+    });
+  });
+  test('Diagnostics Array', () => {
+    const matches = linter['parseLinterOutput'](msg);
+    const ref = [
+      new Diagnostic(
+        new Range(new Position(2, 17), new Position(2, 17)),
+        '(1)',
+        DiagnosticSeverity.Error
+      ),
+    ];
+    deepStrictEqual(matches, ref);
+  });
+});
+suite('GNU (gfortran v11+) lint multiple plain output', () => {
+  const linter = new FortranLintingProvider();
+  linter['compiler'] = 'gfortran';
+  linter['settings']['modernGNU'] = true;
+  const msg = `
+err-mod.f90:3:17: Error: (1)
+err-mod.f90:2:11: Error: IMPLICIT NONE statement at (1) cannot follow PRIVATE statement at (2)
+err-mod.f90:10:22: Error: Missing actual argument for argument ‘arg1’ at (1)`;
+  suite('REGEX matches', () => {
+    const regex = linter['getCompilerREGEX'](linter['compiler']);
+    const matches = [...msg.matchAll(regex)];
+    const g = matches[0].groups;
+    test('REGEX: filename', () => {
+      strictEqual(g?.['fname'], 'err-mod.f90');
+    });
+    test('REGEX: line number', () => {
+      strictEqual(g?.['ln'], '3');
+    });
+    test('REGEX: column number', () => {
+      strictEqual(g?.['cn'], '17');
+    });
+    test('REGEX: severity <sev>', () => {
+      strictEqual(g?.['sev'], 'Error');
+    });
+    test('REGEX: message <msg>', () => {
+      strictEqual(g?.['msg'], '(1)');
+    });
+
+    const g2 = matches[1].groups;
+    test('REGEX: filename', () => {
+      strictEqual(g2?.['fname'], 'err-mod.f90');
+    });
+    test('REGEX: line number', () => {
+      strictEqual(g2?.['ln'], '2');
+    });
+    test('REGEX: column number', () => {
+      strictEqual(g2?.['cn'], '11');
+    });
+    test('REGEX: severity <sev>', () => {
+      strictEqual(g2?.['sev'], 'Error');
+    });
+    test('REGEX: message <msg>', () => {
+      strictEqual(
+        g2?.['msg'],
+        'IMPLICIT NONE statement at (1) cannot follow PRIVATE statement at (2)'
+      );
+    });
+
+    const g3 = matches[2].groups;
+    test('REGEX: filename', () => {
+      strictEqual(g3?.['fname'], 'err-mod.f90');
+    });
+    test('REGEX: line number', () => {
+      strictEqual(g3?.['ln'], '10');
+    });
+    test('REGEX: column number', () => {
+      strictEqual(g3?.['cn'], '22');
+    });
+    test('REGEX: severity <sev>', () => {
+      strictEqual(g3?.['sev'], 'Error');
+    });
+    test('REGEX: message <msg>', () => {
+      strictEqual(g3?.['msg'], 'Missing actual argument for argument ‘arg1’ at (1)');
+    });
+  });
+
+  test('Diagnostics Array', () => {
+    const matches = linter['parseLinterOutput'](msg);
+    const ref = [
+      new Diagnostic(
+        new Range(new Position(2, 17), new Position(2, 17)),
+        '(1)',
+        DiagnosticSeverity.Error
+      ),
+      new Diagnostic(
+        new Range(new Position(1, 11), new Position(1, 11)),
+        'IMPLICIT NONE statement at (1) cannot follow PRIVATE statement at (2)',
+        DiagnosticSeverity.Error
+      ),
+      new Diagnostic(
+        new Range(new Position(9, 22), new Position(9, 22)),
+        'Missing actual argument for argument ‘arg1’ at (1)',
+        DiagnosticSeverity.Error
+      ),
+    ];
+    deepStrictEqual(matches, ref);
+  });
+});
 
 // -----------------------------------------------------------------------------