code lens skeleton.

Signed-off-by: Akos Kitta <[email protected]>

Author: Akos Kitta

arduino-ide-extension/src/browser/arduino-ide-frontend-module.ts

@@ -292,7 +292,7 @@ import { PreferenceTreeGenerator as TheiaPreferenceTreeGenerator } from '@theia/
 import { AboutDialog } from './theia/core/about-dialog';
 import { AboutDialog as TheiaAboutDialog } from '@theia/core/lib/browser/about-dialog';
 import { CoreErrorHandler } from './contributions/core-error-handler';
-import { EditorDecorations } from './contributions/editor-decorations';
+import { CompilerErrors } from './contributions/editor-decorations';
 
 MonacoThemingService.register({
   id: 'arduino-theme',
@@ -671,7 +671,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
   Contribution.configure(bind, AddZipLibrary);
   Contribution.configure(bind, PlotterFrontendContribution);
   Contribution.configure(bind, Format);
-  Contribution.configure(bind, EditorDecorations);
+  Contribution.configure(bind, CompilerErrors);
 
   // Disabled the quick-pick customization from Theia when multiple formatters are available.
   // Use the default VS Code behavior, and pick the first one. In the IDE2, clang-format has `exclusive` selectors.

arduino-ide-extension/src/browser/contributions/editor-decorations.ts

@@ -15,14 +15,23 @@ import {
   EditorDecoration,
   TrackedRangeStickiness,
 } from '@theia/editor/lib/browser/decorations/editor-decoration';
-
+import * as monaco from '@theia/monaco-editor-core';
+import { InoSelector } from '../ino-selectors';
+import { ProtocolToMonacoConverter } from '@theia/monaco/lib/browser/protocol-to-monaco-converter';
 @injectable()
-export class EditorDecorations extends Contribution {
+export class CompilerErrors
+  extends Contribution
+  implements monaco.languages.CodeLensProvider
+{
   @inject(EditorManager)
   private readonly editorManager: EditorManager;
 
+  @inject(ProtocolToMonacoConverter)
+  private readonly p2m: ProtocolToMonacoConverter;
+
   @inject(CoreErrorHandler)
   private readonly coreErrorHandler: CoreErrorHandler;
+  private readonly compilerErrors = new Map<string, CoreError.Compiler[]>();
 
   private shell: ApplicationShell | undefined;
 
@@ -31,52 +40,89 @@ export class EditorDecorations extends Contribution {
 
   override onStart(app: FrontendApplication): void {
     this.shell = app.shell;
+    monaco.languages.registerCodeLensProvider(InoSelector, this);
     this.coreErrorHandler.onCompilerErrorsDidChange((errors) =>
       this.handleCompilerErrorsDidChange(errors)
     );
   }
 
+  provideCodeLenses(
+    model: monaco.editor.ITextModel,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _token: monaco.CancellationToken
+  ): monaco.languages.ProviderResult<monaco.languages.CodeLensList> {
+    const lenses: monaco.languages.CodeLens[] = [];
+    const errors = this.compilerErrors.get(model.uri.toString());
+    // Do not show "jump next" when one is available
+    if (errors && errors.length > 1) {
+      errors.forEach((error, index, self) => {
+        lenses.push({
+          range: this.p2m.asRange(error.location.range),
+          command: {
+            id: 'some-id',
+            title: 'hey',
+            tooltip: 'blabla',
+          },
+        });
+      });
+    }
+    return {
+      lenses,
+      dispose: () => {
+        /*noop*/
+      },
+    };
+  }
+
   private async handleCompilerErrorsDidChange(
     errors: CoreError.Compiler[]
   ): Promise<void> {
     this.toDisposeOnCompilerErrorDidChange.dispose();
-    this.toDisposeOnCompilerErrorDidChange.pushAll(
-      await Promise.all([
-        this.decorateEditors(errors),
-        this.registerCodeLens(errors),
-      ])
+    Array.from(this.groupByResource(errors).entries()).forEach(([uri, error]) =>
+      this.compilerErrors.set(uri, error)
     );
+    this.toDisposeOnCompilerErrorDidChange.pushAll([
+      Disposable.create(() => this.compilerErrors.clear()),
+      ...(await Promise.all([
+        this.decorateEditors(this.compilerErrors),
+        this.registerCodeLens(this.compilerErrors),
+      ])),
+    ]);
     const first = errors[0];
     if (first) {
       await this.revealLocationInEditor(first.location);
     }
   }
 
   private async decorateEditors(
-    errors: CoreError.Compiler[]
+    errors: Map<string, CoreError.Compiler[]>
   ): Promise<Disposable> {
     return new DisposableCollection(
       ...(await Promise.all(
-        [
-          ...errors
-            .reduce((acc, curr) => {
-              const {
-                location: { uri },
-              } = curr;
-              let errors = acc.get(uri);
-              if (!errors) {
-                errors = [];
-                acc.set(uri, errors);
-              }
-              errors.push(curr);
-              return acc;
-            }, new Map<string, CoreError.Compiler[]>())
-            .entries(),
-        ].map(([uri, errors]) => this.decorateEditor(uri, errors))
+        [...errors.entries()].map(([uri, errors]) =>
+          this.decorateEditor(uri, errors)
+        )
       ))
     );
   }
 
+  private groupByResource(
+    errors: CoreError.Compiler[]
+  ): Map<string, CoreError.Compiler[]> {
+    return errors.reduce((acc, curr) => {
+      const {
+        location: { uri },
+      } = curr;
+      let errors = acc.get(uri);
+      if (!errors) {
+        errors = [];
+        acc.set(uri, errors);
+      }
+      errors.push(curr);
+      return acc;
+    }, new Map<string, CoreError.Compiler[]>());
+  }
+
   private async decorateEditor(
     uri: string,
     errors: CoreError.Compiler[]
@@ -112,7 +158,7 @@ export class EditorDecorations extends Contribution {
   }
 
   private async registerCodeLens(
-    errors: CoreError.Compiler[]
+    errors: Map<string, CoreError.Compiler[]>
   ): Promise<Disposable> {
     return new DisposableCollection();
   }

arduino-ide-extension/src/browser/contributions/format.ts

@@ -2,6 +2,7 @@ import { MaybePromise } from '@theia/core';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import * as monaco from '@theia/monaco-editor-core';
 import { Formatter } from '../../common/protocol/formatter';
+import { InoSelector } from '../ino-selectors';
 import { Contribution, URI } from './contribution';
 
 @injectable()
@@ -15,12 +16,11 @@ export class Format
   private readonly formatter: Formatter;
 
   override onStart(): MaybePromise<void> {
-    const selector = this.selectorOf('ino', 'c', 'cpp', 'h', 'hpp', 'pde');
     monaco.languages.registerDocumentRangeFormattingEditProvider(
-      selector,
+      InoSelector,
       this
     );
-    monaco.languages.registerDocumentFormattingEditProvider(selector, this);
+    monaco.languages.registerDocumentFormattingEditProvider(InoSelector, this);
   }
   async provideDocumentRangeFormattingEdits(
     model: monaco.editor.ITextModel,
@@ -82,13 +82,4 @@ export class Format
       options,
     });
   }
-
-  private selectorOf(
-    ...languageId: string[]
-  ): monaco.languages.LanguageSelector {
-    return languageId.map((language) => ({
-      language,
-      exclusive: true, // <-- this should make sure the custom formatter has higher precedence over the LS formatter.
-    }));
-  }
 }

arduino-ide-extension/src/browser/ino-selectors.ts

@@ -0,0 +1,13 @@
+import * as monaco from '@theia/monaco-editor-core';
+/**
+ * Exclusive "ino" document selector for monaco.
+ */
+export const InoSelector = selectorOf('ino', 'c', 'cpp', 'h', 'hpp', 'pde');
+function selectorOf(
+  ...languageId: string[]
+): monaco.languages.LanguageSelector {
+  return languageId.map((language) => ({
+    language,
+    exclusive: true, // <-- this should make sure the custom formatter has higher precedence over the LS formatter.
+  }));
+}