Add diagnostic display in the UI.

Author: whitequark

example/Makefile

@@ -9,7 +9,7 @@ design_sim: design_sim.cc design.cc
 	clang++ $(CXXFLAGS) -o $@ $(abspath $^)
 
 design.h: design.cc
-design.cc: design.v
+design.cc: design.sv
 	$(YOSYS) -q $(abspath $^) -p hierarchy -p 'write_cxxrtl -header $@'
 
 clean:

example/design.v renamed to example/design.sv

@@ -54,4 +54,10 @@ module top(
     .cnt(timer),
   );
 
+  always @(*)
+    $display("message_index = %d, timer = %d", message_index, timer);
+
+  always @(posedge clk)
+    assert (timer < 5);
+
 endmodule

src/extension.ts

@@ -5,6 +5,7 @@ import * as sidebar from './ui/sidebar';
 import { globalWatchList } from './debug/watch';
 import { globalVariableOptions } from './debug/options';
 import { HoverProvider } from './ui/hover';
+import { DiagnosticProvider } from './ui/diagnostic';
 import { inputTime } from './ui/input';
 
 export function activate(context: vscode.ExtensionContext) {
@@ -21,6 +22,10 @@ export function activate(context: vscode.ExtensionContext) {
         context.subscriptions.push(vscode.languages.registerHoverProvider(language, hoverProvider));
     }
 
+    const diagnosticCollection = vscode.languages.createDiagnosticCollection('rtlDebugger');
+    const diagnosticProvider = new DiagnosticProvider(rtlDebugger, diagnosticCollection);
+    context.subscriptions.push(diagnosticProvider);
+
     vscode.commands.executeCommand('setContext', 'rtlDebugger.sessionStatus', rtlDebugger.sessionStatus);
     context.subscriptions.push(rtlDebugger.onDidChangeSessionStatus((state) =>
         vscode.commands.executeCommand('setContext', 'rtlDebugger.sessionStatus', state)));

src/model/source.ts

@@ -3,6 +3,7 @@ import * as vscode from 'vscode';
 export class Location {
     constructor(
         readonly file: string,
+        // All zero-based, like VS Code itself.
         readonly startLine: number,
         readonly startColumn?: number,
         readonly endLine?: number,
@@ -26,10 +27,23 @@ export class Location {
         );
     }
 
+    get fileUri(): vscode.Uri {
+        return vscode.Uri.file(this.file);
+    }
+
+    get range(): vscode.Range {
+        return new vscode.Range(
+            this.startLine,
+            this.startColumn ?? 0,
+            this.endLine ?? this.startLine,
+            this.endColumn ?? this.startColumn ?? 0
+        );
+    }
+
     private openCommandArguments(): [vscode.Uri, vscode.TextDocumentShowOptions] {
-        const position = new vscode.Position(this.startLine || 0, this.startColumn || 0);
+        const position = new vscode.Position(this.startLine, this.startColumn ?? 0);
         return [
-            vscode.Uri.parse(this.file),
+            this.fileUri,
             {
                 selection: new vscode.Selection(position, position),
                 preview: true,

src/ui/diagnostic.ts

@@ -0,0 +1,99 @@
+import * as vscode from 'vscode';
+
+import { CXXRTLDebugger } from '../debugger';
+import { Diagnostic, DiagnosticType } from '../model/sample';
+import { Session } from '../debug/session';
+
+export class DiagnosticProvider {
+    constructor(
+        private rtlDebugger: CXXRTLDebugger,
+        private diagnosticCollection: vscode.DiagnosticCollection,
+    ) {
+        rtlDebugger.onDidChangeSession((session) => {
+            this.update(session);
+            if (session !== null) {
+                session.onDidChangeSimulationStatus((_simulationStatus) => this.update(session));
+                session.onDidChangeTimeCursor((_timeCursor) => this.update(session));
+            }
+        });
+    }
+
+    dispose() {
+        this.diagnosticCollection.dispose();
+    }
+
+    private async update(session: Session | null) {
+        if (session === null || session?.simulationStatus.status === 'running') {
+            this.apply([]);
+        } else {
+            const sample = await session.queryAtCursor({ diagnostics: true });
+            this.apply(sample.diagnostics!);
+        }
+    }
+
+    private apply(diagnostics: Diagnostic[]) {
+        const diagnosticMap = new Map();
+        for (const diagnostic of diagnostics) {
+            if (diagnostic.location === null) {
+                continue;
+            }
+            const uri = diagnostic.location.fileUri;
+            const range = diagnostic.location.range;
+            if (!diagnosticMap.has(uri)) {
+                diagnosticMap.set(uri, []);
+            }
+
+            console.warn('[RTL Debugger]', diagnostic);
+
+            let message;
+            let severity;
+            switch (diagnostic.type) {
+                case DiagnosticType.Break:
+                    if (diagnostic.text !== '') {
+                        message = `breakpoint: ${diagnostic.text}`;
+                    } else {
+                        message = 'breakpoint';
+                    }
+                    severity = vscode.DiagnosticSeverity.Warning;
+                    break;
+
+                case DiagnosticType.Print:
+                    message = diagnostic.text;
+                    severity = vscode.DiagnosticSeverity.Information;
+                    break;
+
+                case DiagnosticType.Assert:
+                    if (diagnostic.text !== '') {
+                        message = `assertion violated: ${diagnostic.text}`;
+                    } else {
+                        message = 'assertion violated';
+                    }
+                    severity = vscode.DiagnosticSeverity.Error;
+                    break;
+
+                case DiagnosticType.Assume:
+                    if (diagnostic.text !== '') {
+                        message = `assumption violated: ${diagnostic.text}`;
+                    } else {
+                        message = 'assumption violated';
+                    }
+                    severity = vscode.DiagnosticSeverity.Error;
+                    break;
+
+                default:
+                    message = `(unknown diagnostic type ${diagnostic.type}): ${diagnostic.text}`;
+                    severity = vscode.DiagnosticSeverity.Error;
+                    break;
+            }
+            if (message !== '') {
+                const mappedDiagnostic = new vscode.Diagnostic(range, message, severity);
+                mappedDiagnostic.code = <string>diagnostic.type;
+                mappedDiagnostic.source = 'RTL Debug';
+                diagnosticMap.get(uri).push(mappedDiagnostic);
+            }
+        }
+
+        this.diagnosticCollection.clear();
+        this.diagnosticCollection.set(Array.from(diagnosticMap.entries()));
+    }
+}

src/ui/status.ts

@@ -12,8 +12,8 @@ export class StatusBarItem {
         rtlDebugger.onDidChangeSession((session) => {
             this.update(session);
             if (session !== null) {
-                session.onDidChangeSimulationStatus((_status) => this.update(session));
-                session.onDidChangeTimeCursor((_time) => this.update(session));
+                session.onDidChangeSimulationStatus((_simulationStatus) => this.update(session));
+                session.onDidChangeTimeCursor((_timeCursor) => this.update(session));
             }
         });
     }