Add diagnostic support to Query Interval.

Author: whitequark

src/debug/observer.ts

@@ -87,7 +87,7 @@ export class Observer {
                 this.reference = this.session.bindReference(this.referenceName, unboundReference);
             }
             const reference = this.reference; // could get invalidated during `await` below
-            const sample = await this.session.queryAtCursor(reference);
+            const sample = await this.session.queryAtCursor({ reference });
             for (const [designation, handle] of reference.allHandles()) {
                 const observable = this.observables.get(designation.canonicalKey)!;
                 observable.update(sample.extract(handle));

src/debug/session.ts

@@ -4,14 +4,15 @@ import * as proto from '../cxxrtl/proto';
 import { ILink } from '../cxxrtl/link';
 import { Connection } from '../cxxrtl/client';
 import { TimeInterval, TimePoint } from '../model/time';
-import { Reference, Sample, UnboundReference } from '../model/sample';
+import { Diagnostic, Reference, Sample, UnboundReference } from '../model/sample';
 import { Variable } from '../model/variable';
 import { Scope } from '../model/scope';
 import { Location } from '../model/source';
 
 function lazy<T>(thunk: () => Thenable<T>): Thenable<T> {
     return { then: (onfulfilled, onrejected) => thunk().then(onfulfilled, onrejected) };
 }
+
 function matchLocation(location: Location, filename: string, position: vscode.Position) {
     if (location.file !== filename) {
         return false;
@@ -214,38 +215,55 @@ export class Session {
     }
 
     async queryInterval(
-        reference: Reference,
         interval: TimeInterval,
-        options: { collapse?: boolean } = {}
+        options: {
+            reference?: Reference,
+            diagnostics?: boolean
+            collapse?: boolean,
+        } = {}
     ): Promise<Sample[]> {
-        this.checkReferenceEpoch(reference.name, reference.epoch);
+        const reference = options.reference;
+        if (reference !== undefined) {
+            this.checkReferenceEpoch(reference.name, reference.epoch);
+        }
         const response = await this.connection.queryInterval({
             type: 'command',
             command: 'query_interval',
             interval: interval.toCXXRTL(),
+            items: reference?.name ?? null,
+            item_values_encoding: reference ? 'base64(u32)' : null,
+            diagnostics: options.diagnostics ?? false,
             collapse: options.collapse ?? true,
-            items: reference.name,
-            item_values_encoding: 'base64(u32)',
-            diagnostics: false
         });
         return response.samples.map((cxxrtlSample) => {
-            const itemValuesBuffer = Buffer.from(cxxrtlSample.item_values!, 'base64');
-            const itemValuesArray = new Uint32Array(
-                itemValuesBuffer.buffer,
-                itemValuesBuffer.byteOffset,
-                itemValuesBuffer.length / Uint32Array.BYTES_PER_ELEMENT
-            );
+            let itemValuesArray = null;
+            let diagnosticsArray = null;
+            if (cxxrtlSample.item_values !== undefined) {
+                const itemValuesBuffer = Buffer.from(cxxrtlSample.item_values, 'base64');
+                itemValuesArray = new Uint32Array(
+                    itemValuesBuffer.buffer,
+                    itemValuesBuffer.byteOffset,
+                    itemValuesBuffer.length / Uint32Array.BYTES_PER_ELEMENT
+                );
+            }
+            if (cxxrtlSample.diagnostics !== undefined) {
+                diagnosticsArray = Array.from(cxxrtlSample.diagnostics, Diagnostic.fromCXXRTL);
+            }
             return new Sample(
                 TimePoint.fromCXXRTL(cxxrtlSample.time),
-                reference.unbound,
-                itemValuesArray
+                reference?.unbound ?? null,
+                itemValuesArray,
+                diagnosticsArray,
             );
         });
     }
 
-    async queryAtCursor(reference: Reference): Promise<Sample> {
+    async queryAtCursor(options: {
+        reference?: Reference,
+        diagnostics?: boolean
+    }): Promise<Sample> {
         const interval = new TimeInterval(this.timeCursor, this.timeCursor);
-        const [sample] = await this.queryInterval(reference, interval);
+        const [sample] = await this.queryInterval(interval, options);
         return sample;
     }
 

src/model/sample.ts

@@ -1,4 +1,5 @@
 import * as proto from '../cxxrtl/proto';
+import { Location } from './source';
 import { TimePoint } from './time';
 import { MemoryVariable, ScalarVariable, Variable } from './variable';
 
@@ -176,16 +177,47 @@ export class Reference {
     }
 }
 
+export enum DiagnosticType {
+    Break = 'break',
+    Print = 'print',
+    Assert = 'assert',
+    Assume = 'assume',
+}
+
+export class Diagnostic {
+    constructor(
+        readonly type: DiagnosticType,
+        readonly text: string,
+        readonly location: Location | null,
+    ) {}
+
+    static fromCXXRTL(cxxrtlDiagnostic: proto.Diagnostic): Diagnostic {
+        return new Diagnostic(
+            <DiagnosticType>cxxrtlDiagnostic.type,
+            cxxrtlDiagnostic.text,
+            Location.fromCXXRTL(cxxrtlDiagnostic.src)
+        );
+    }
+}
+
 export class Sample {
     constructor(
         readonly time: TimePoint,
-        readonly reference: UnboundReference,
-        readonly variableData: Uint32Array,
-    ) {}
+        readonly reference: UnboundReference | null,
+        readonly variableData: Uint32Array | null,
+        readonly diagnostics: Diagnostic[] | null,
+    ) {
+        if ((this.reference === null) !== (this.variableData === null)) {
+            throw new Error('A sample must include both a reference and variable data, or neither');
+        }
+    }
 
     extract<T>(handle: Handle<T>): T {
         if (handle.reference !== this.reference) {
-            throw new ReferenceError('Handle is not bound to the same reference as the sample');
+            throw new Error('Handle is not bound to the same reference as the sample');
+        }
+        if (this.variableData === null) {
+            throw new Error('Sample does not include item values');
         }
         return handle.extractFromRaw(this.variableData);
     }

src/ui/hover.ts

@@ -26,7 +26,7 @@ export class HoverProvider implements vscode.HoverProvider {
             }
         }
         const reference = session.bindReference('hover', unboundReference);
-        const sample = await session.queryAtCursor(reference);
+        const sample = await session.queryAtCursor({ reference });
         for (const [designation, handle] of reference.allHandles()) {
             const variable = designation.variable;
             const descriptionText = variableDescription(displayStyle, variable);