feat: Add LFortran as linter

see LFortran PR lfortran/lfortran#647
Fixes #589

Author: gnikit

CHANGELOG.md

@@ -9,6 +9,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Added
 
+- Added linter support for [LFortran](https://lfortran.org/)
+  ([#589](https://github.com/fortran-lang/vscode-fortran-support/issues/589))
 - Added coverage reporting using `c8`
   ([#613](https://github.com/fortran-lang/vscode-fortran-support/issues/613))
 - Added support for enhanced `gfotran` v11+ diagnostics using `-fdiagnostics-plain-output`

package.json

@@ -219,6 +219,7 @@
               "ifort",
               "ifx",
               "nagfor",
+              "lfortran",
               "Disabled"
             ],
             "markdownDescription": "Compiler used for linting support.",

src/features/linter-provider.ts

@@ -7,7 +7,7 @@ import * as semver from 'semver';
 import * as vscode from 'vscode';
 
 import { Logger } from '../services/logging';
-import { GNULinter, GNUModernLinter, IntelLinter, NAGLinter } from '../lib/linters';
+import { GNULinter, GNUModernLinter, IntelLinter, LFortranLinter, NAGLinter } from '../lib/linters';
 import {
   EXTENSION_ID,
   FortranDocumentSelector,
@@ -136,6 +136,7 @@ const GNU = new GNULinter();
 const GNU_NEW = new GNUModernLinter();
 const INTEL = new IntelLinter();
 const NAG = new NAGLinter();
+const LFORTRAN = new LFortranLinter();
 
 export class FortranLintingProvider {
   constructor(private logger: Logger = new Logger()) {
@@ -261,6 +262,8 @@ export class FortranLintingProvider {
         return INTEL;
       case 'nagfor':
         return NAG;
+      case 'lfortran':
+        return LFORTRAN;
       default:
         return GNU;
     }

src/lib/linters.ts

@@ -234,3 +234,50 @@ export class NAGLinter extends Linter {
     return diagnostics;
   }
 }
+
+export class LFortranLinter extends Linter {
+  constructor() {
+    super(
+      'lfortran',
+      /(?<fname>(?:\w:\\)?.*):(?<ls>\d+)-(?<le>\d+):(?<cs>\d+)-(?<ce>\d+): (?<sev>.+): (?<msg>.+)/g,
+      {
+        errors: [
+          'C preprocessor error',
+          'prescanner error',
+          'tokenizer error',
+          'syntax error',
+          'semantic error',
+          'ASR pass error',
+          'code generation error',
+        ],
+        warnings: ['warning'],
+        infos: ['note'],
+        hints: ['help', 'style suggestion'],
+      },
+      ['--error-format=short'],
+      [],
+      '-J'
+    );
+  }
+
+  /**
+   * <filename>:<line start>-<end>:<column start>-<end>: <severity>: <message>
+   * @param msg linter results
+   * @returns array of vscode.Diagnostic
+   */
+  public parse(msg: string): vscode.Diagnostic[] {
+    const matches = [...msg.matchAll(this.regex)];
+    const diagnostics: vscode.Diagnostic[] = [];
+    for (const m of matches) {
+      const g = m.groups;
+      const [_, name, ls, le, cs, ce, msg_type, msg] = m;
+      const range = new vscode.Range(
+        new vscode.Position(parseInt(ls) - 1, parseInt(cs) - 1),
+        new vscode.Position(parseInt(le) - 1, parseInt(ce))
+      );
+      const severity = this.getSeverityLevel(msg_type.toLowerCase());
+      diagnostics.push(new vscode.Diagnostic(range, msg, severity));
+    }
+    return diagnostics;
+  }
+}

test/linter-provider.test.ts

@@ -13,7 +13,13 @@ import {
 import * as fg from 'fast-glob';
 
 import { FortranLintingProvider } from '../src/features/linter-provider';
-import { GNULinter, GNUModernLinter, IntelLinter, NAGLinter } from '../src/lib/linters';
+import {
+  GNULinter,
+  GNUModernLinter,
+  IntelLinter,
+  NAGLinter,
+  LFortranLinter,
+} from '../src/lib/linters';
 import { EXTENSION_ID, pipInstall } from '../src/lib/tools';
 
 suite('Linter integration', () => {
@@ -75,7 +81,7 @@ suite('Linter integration', () => {
   });
 
   test('Linter user setting returns the right linter internally', () => {
-    const names = ['gfortran', 'ifort', 'ifx', 'nagfor', 'fake'];
+    const names = ['gfortran', 'ifort', 'ifx', 'nagfor', 'lfortran', 'fake'];
     for (const n of names) {
       const compiler = linter['getLinter'](n);
       if (n === 'gfortran') {
@@ -88,6 +94,8 @@ suite('Linter integration', () => {
         strictEqual(compiler instanceof IntelLinter, true);
       } else if (n === 'nagfor') {
         strictEqual(compiler instanceof NAGLinter, true);
+      } else if (n == 'lfortran') {
+        strictEqual(compiler instanceof LFortranLinter, true);
       } else {
         strictEqual(compiler instanceof GNULinter, true);
       }
@@ -787,3 +795,48 @@ Sequence Error: lint/err-mod.f90, line 3: The IMPLICIT statement cannot occur he
     deepStrictEqual(diags, ref);
   });
 });
+
+// -----------------------------------------------------------------------------
+
+suite('LFortran (lfortran) lint single', () => {
+  const linter = new LFortranLinter();
+  const msg = `
+lint/err-mod.f90:3-3:5-12: syntax error: Token 'implicit' is unexpected here
+`;
+  suite('REGEX matches', () => {
+    const matches = [...msg.matchAll(linter.regex)];
+    const g = matches[0].groups;
+    test('REGEX: filename', () => {
+      strictEqual(g?.['fname'], 'lint/err-mod.f90');
+    });
+    test('REGEX: line number start <ls>', () => {
+      strictEqual(g?.['ls'], '3');
+    });
+    test('REGEX: line number end <le>', () => {
+      strictEqual(g?.['le'], '3');
+    });
+    test('REGEX: column number start <cs>', () => {
+      strictEqual(g?.['cs'], '5');
+    });
+    test('REGEX: column number end <ce>', () => {
+      strictEqual(g?.['ce'], '12');
+    });
+    test('REGEX: severity <sev>', () => {
+      strictEqual(g?.['sev'], 'syntax error');
+    });
+    test('REGEX: message <msg>', () => {
+      strictEqual(g?.['msg'], `Token 'implicit' is unexpected here`);
+    });
+  });
+  test('Diagnostics Array', () => {
+    const diags = linter.parse(msg);
+    const ref = [
+      new Diagnostic(
+        new Range(new Position(2, 4), new Position(2, 12)),
+        `Token 'implicit' is unexpected here`,
+        DiagnosticSeverity.Error
+      ),
+    ];
+    deepStrictEqual(diags, ref);
+  });
+});