qsharp-lang 1.0.22-rc → 1.0.24-dev

package/dist/compiler/compiler.d.ts

@@ -7,6 +7,7 @@ export interface ICompiler {
     getHir(code: string): Promise<string>;
     run(code: string, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
     getQir(code: string): Promise<string>;
+    getEstimates(code: string, params: string): Promise<string>;
     checkExerciseSolution(user_code: string, exercise_sources: string[], eventHandler: IQscEventTarget): Promise<boolean>;
 }
 export type ICompilerWorker = ICompiler & IServiceProxy;
@@ -16,6 +17,7 @@ export declare class Compiler implements ICompiler {
     constructor(wasm: Wasm);
     checkCode(code: string): Promise<VSDiagnostic[]>;
     getQir(code: string): Promise<string>;
+    getEstimates(code: string, params: string): Promise<string>;
     getHir(code: string): Promise<string>;
     run(code: string, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
     checkExerciseSolution(user_code: string, exercise_sources: string[], eventHandler: IQscEventTarget): Promise<boolean>;

package/dist/compiler/compiler.js

@@ -21,6 +21,9 @@ export class Compiler {
     async getQir(code) {
         return this.wasm.get_qir(code);
     }
+    async getEstimates(code, params) {
+        return this.wasm.get_estimates(code, params);
+    }
     async getHir(code) {
         return this.wasm.get_hir(code);
     }

package/dist/compiler/events.d.ts

@@ -29,7 +29,6 @@ export declare class QscEventTarget implements IQscEventTarget {
     private results;
     private shotActive;
     private animationFrameId;
-    private supportsUiRefresh;
     addEventListener<T extends QscUiEvents["type"]>(type: T, listener: (event: Extract<QscEvents, {
         type: T;
     }>) => void): void;

package/dist/compiler/events.js

@@ -31,9 +31,6 @@ export class QscEventTarget {
         this.results = [];
         this.shotActive = false;
         this.animationFrameId = 0;
-        this.supportsUiRefresh = false;
-        this.supportsUiRefresh =
-            typeof globalThis.requestAnimationFrame === "function";
         if (captureEvents) {
             this.addEventListener("Message", (ev) => this.onMessage(ev.detail));
             this.addEventListener("DumpMachine", (ev) => this.onDumpMachine(ev.detail));
@@ -67,10 +64,10 @@ export class QscEventTarget {
         }
     }
     queueUiRefresh() {
-        if (this.supportsUiRefresh && !this.animationFrameId) {
-            this.animationFrameId = requestAnimationFrame(() => {
+        if (!this.animationFrameId) {
+            this.animationFrameId = setTimeout(() => {
                 this.onUiRefresh();
-            });
+            }, 50); // 20 fps is plenty for the rendering we do
         }
     }
     onUiRefresh() {

package/dist/compiler/worker-proxy.js

@@ -5,6 +5,7 @@ const requests = {
     checkCode: "request",
     getHir: "request",
     getQir: "request",
+    getEstimates: "request",
     run: "requestWithProgress",
     checkExerciseSolution: "requestWithProgress",
 };

package/dist/debug-service/debug-service.d.ts

@@ -3,7 +3,7 @@ import { IQscEventTarget } from "../compiler/events.js";
 import { IServiceProxy } from "../worker-proxy.js";
 type QscWasm = typeof import("../../lib/node/qsc_wasm.cjs");
 export interface IDebugService {
-    loadSource(path: string, source: string, entry: string | undefined): Promise<string>;
+    loadSource(path: string, source: string, target: "base" | "full", entry: string | undefined): Promise<string>;
     getBreakpoints(path: string): Promise<IBreakpointSpan[]>;
     getLocalVariables(): Promise<Array<IVariable>>;
     captureQuantumState(): Promise<Array<IQuantumState>>;
@@ -20,7 +20,7 @@ export declare class QSharpDebugService implements IDebugService {
     private debugService;
     private code;
     constructor(wasm: QscWasm);
-    loadSource(path: string, source: string, entry: string | undefined): Promise<string>;
+    loadSource(path: string, source: string, target: "base" | "full", entry: string | undefined): Promise<string>;
     getStackFrames(): Promise<IStackFrame[]>;
     evalNext(bps: number[], eventHandler: IQscEventTarget): Promise<IStructStepResult>;
     evalStepIn(bps: number[], eventHandler: IQscEventTarget): Promise<IStructStepResult>;

package/dist/debug-service/debug-service.js

@@ -12,9 +12,9 @@ export class QSharpDebugService {
         this.wasm = wasm;
         this.debugService = new wasm.DebugService();
     }
-    async loadSource(path, source, entry) {
+    async loadSource(path, source, target, entry) {
         this.code[path] = source;
-        return this.debugService.load_source(path, source, entry);
+        return this.debugService.load_source(path, source, target, entry);
     }
     async getStackFrames() {
         const stack_frame_list = this.debugService.get_stack_frames();

package/dist/language-service/language-service.d.ts

@@ -13,7 +13,13 @@ export type LanguageServiceEvent = {
 export interface ILanguageService {
     updateConfiguration(config: IWorkspaceConfiguration): Promise<void>;
     updateDocument(uri: string, version: number, code: string): Promise<void>;
+    updateNotebookDocument(notebookUri: string, version: number, cells: {
+        uri: string;
+        version: number;
+        code: string;
+    }[]): Promise<void>;
     closeDocument(uri: string): Promise<void>;
+    closeNotebookDocument(notebookUri: string, cellUris: string[]): Promise<void>;
     getCompletions(documentUri: string, offset: number): Promise<ICompletionList>;
     getHover(documentUri: string, offset: number): Promise<IHover | undefined>;
     getDefinition(documentUri: string, offset: number): Promise<ILocation | undefined>;
@@ -38,7 +44,13 @@ export declare class QSharpLanguageService implements ILanguageService {
     constructor(wasm: QscWasm);
     updateConfiguration(config: IWorkspaceConfiguration): Promise<void>;
     updateDocument(documentUri: string, version: number, code: string): Promise<void>;
+    updateNotebookDocument(notebookUri: string, version: number, cells: {
+        uri: string;
+        version: number;
+        code: string;
+    }[]): Promise<void>;
     closeDocument(documentUri: string): Promise<void>;
+    closeNotebookDocument(documentUri: string, cellUris: string[]): Promise<void>;
     getCompletions(documentUri: string, offset: number): Promise<ICompletionList>;
     getHover(documentUri: string, offset: number): Promise<IHover | undefined>;
     getDefinition(documentUri: string, offset: number): Promise<ILocation | undefined>;
@@ -53,6 +65,6 @@ export declare class QSharpLanguageService implements ILanguageService {
     removeEventListener<T extends LanguageServiceEvent["type"]>(type: T, listener: (event: Extract<LanguageServiceEvent, {
         type: T;
     }>) => void): void;
-    onDiagnostics(uri: string, version: number, diagnostics: VSDiagnostic[]): void;
+    onDiagnostics(uri: string, version: number | undefined, diagnostics: VSDiagnostic[]): void;
 }
 export {};

package/dist/language-service/language-service.js

@@ -19,10 +19,23 @@ export class QSharpLanguageService {
         this.code[documentUri] = code;
         this.languageService.update_document(documentUri, version, code);
     }
+    async updateNotebookDocument(notebookUri, version, cells) {
+        // Note: If a cell was deleted, its uri & contents will remain in the map.
+        // This is harmless and it keeps the code simpler to just leave it this way
+        // instead of trying to maintain a perfect map.
+        for (const cell of cells) {
+            this.code[cell.uri] = cell.code;
+        }
+        this.languageService.update_notebook_document(notebookUri, cells);
+    }
     async closeDocument(documentUri) {
         delete this.code[documentUri];
         this.languageService.close_document(documentUri);
     }
+    async closeNotebookDocument(documentUri, cellUris) {
+        cellUris.forEach((uri) => delete this.code[uri]);
+        this.languageService.close_notebook_document(documentUri, cellUris);
+    }
     async getCompletions(documentUri, offset) {
         const code = this.code[documentUri];
         if (code === undefined) {
@@ -32,9 +45,7 @@ export class QSharpLanguageService {
         const convertedOffset = mapUtf16UnitsToUtf8Units([offset], code)[offset];
         const result = this.languageService.get_completions(documentUri, convertedOffset);
         result.items.forEach((item) => item.additionalTextEdits?.forEach((edit) => {
-            const mappedSpan = mapUtf8UnitsToUtf16Units([edit.range.start, edit.range.end], code);
-            edit.range.start = mappedSpan[edit.range.start];
-            edit.range.end = mappedSpan[edit.range.end];
+            updateSpanFromUtf8ToUtf16(edit.range, code);
         }));
         return result;
     }
@@ -47,35 +58,40 @@ export class QSharpLanguageService {
         const convertedOffset = mapUtf16UnitsToUtf8Units([offset], code)[offset];
         const result = this.languageService.get_hover(documentUri, convertedOffset);
         if (result) {
-            const mappedSpan = mapUtf8UnitsToUtf16Units([result.span.start, result.span.end], code);
-            result.span.start = mappedSpan[result.span.start];
-            result.span.end = mappedSpan[result.span.end];
+            updateSpanFromUtf8ToUtf16(result.span, code);
         }
         return result;
     }
     async getDefinition(documentUri, offset) {
-        let code = this.code[documentUri];
-        if (code === undefined) {
+        const sourceCode = this.code[documentUri];
+        if (sourceCode === undefined) {
             log.error(`getDefinition: expected ${documentUri} to be in the document map`);
             return undefined;
         }
-        const convertedOffset = mapUtf16UnitsToUtf8Units([offset], code)[offset];
+        const convertedOffset = mapUtf16UnitsToUtf8Units([offset], sourceCode)[offset];
         const result = this.languageService.get_definition(documentUri, convertedOffset);
         if (result) {
-            // Inspect the URL protocol (equivalent to the URI scheme + ":").
-            // If the scheme is our library scheme, we need to call the wasm to
-            // provide the library file's contents to do the utf8->utf16 mapping.
-            const url = new URL(result.source);
-            if (url.protocol === qsharpLibraryUriScheme + ":") {
-                code = wasm.get_library_source_content(url.pathname);
-                if (code === undefined) {
-                    log.error(`getDefinition: expected ${url} to be in the library`);
-                    return undefined;
+            let targetCode = this.code[result.source];
+            if (targetCode === undefined) {
+                // Inspect the URL protocol (equivalent to the URI scheme + ":").
+                // If the scheme is our library scheme, we need to call the wasm to
+                // provide the library file's contents to do the utf8->utf16 mapping.
+                const url = new URL(result.source);
+                if (url.protocol === qsharpLibraryUriScheme + ":") {
+                    targetCode = wasm.get_library_source_content(url.pathname);
+                    if (targetCode === undefined) {
+                        log.error(`getDefinition: expected ${url} to be in the library`);
+                        return undefined;
+                    }
                 }
             }
-            const mappedSpan = mapUtf8UnitsToUtf16Units([result.span.start, result.span.end], code);
-            result.span.start = mappedSpan[result.span.start];
-            result.span.end = mappedSpan[result.span.end];
+            if (targetCode) {
+                updateSpanFromUtf8ToUtf16(result.span, targetCode);
+            }
+            else {
+                // https://github.com/microsoft/qsharp/issues/851
+                log.error(`cannot do utf8->utf16 mapping for ${result.source} since contents are not available`);
+            }
         }
         return result;
     }
@@ -102,12 +118,11 @@ export class QSharpLanguageService {
                     }
                 }
                 if (resultCode) {
-                    const mappedSpan = mapUtf8UnitsToUtf16Units([result.span.start, result.span.end], resultCode);
-                    result.span.start = mappedSpan[result.span.start];
-                    result.span.end = mappedSpan[result.span.end];
+                    updateSpanFromUtf8ToUtf16(result.span, resultCode);
                     references.push(result);
                 }
                 else {
+                    // https://github.com/microsoft/qsharp/issues/851
                     log.error(`cannot do utf8->utf16 mapping for ${result.source} since contents are not available`);
                 }
             }
@@ -128,9 +143,7 @@ export class QSharpLanguageService {
         if (result) {
             result.signatures = result.signatures.map((sig) => {
                 sig.parameters = sig.parameters.map((param) => {
-                    const mappedSpan = mapUtf8UnitsToUtf16Units([param.label.start, param.label.end], sig.label);
-                    param.label.start = mappedSpan[param.label.start];
-                    param.label.end = mappedSpan[param.label.end];
+                    updateSpanFromUtf8ToUtf16(param.label, sig.label);
                     return param;
                 });
                 return sig;
@@ -151,9 +164,7 @@ export class QSharpLanguageService {
             const code = this.code[uri];
             if (code) {
                 const mappedEdits = edits.map((edit) => {
-                    const mappedSpan = mapUtf8UnitsToUtf16Units([edit.range.start, edit.range.end], code);
-                    edit.range.start = mappedSpan[edit.range.start];
-                    edit.range.end = mappedSpan[edit.range.end];
+                    updateSpanFromUtf8ToUtf16(edit.range, code);
                     return edit;
                 });
                 mappedChanges.push([uri, mappedEdits]);
@@ -171,9 +182,7 @@ export class QSharpLanguageService {
         const convertedOffset = mapUtf16UnitsToUtf8Units([offset], code)[offset];
         const result = this.languageService.prepare_rename(documentUri, convertedOffset);
         if (result) {
-            const mappedSpan = mapUtf8UnitsToUtf16Units([result.range.start, result.range.end], code);
-            result.range.start = mappedSpan[result.range.start];
-            result.range.end = mappedSpan[result.range.end];
+            updateSpanFromUtf8ToUtf16(result.range, code);
         }
         return result;
     }
@@ -203,7 +212,7 @@ export class QSharpLanguageService {
             const event = new Event("diagnostics");
             event.detail = {
                 uri,
-                version,
+                version: version ?? 0,
                 diagnostics: empty ? [] : mapDiagnostics(diagnostics, code),
             };
             this.eventHandler.dispatchEvent(event);
@@ -213,3 +222,8 @@ export class QSharpLanguageService {
         }
     }
 }
+function updateSpanFromUtf8ToUtf16(span, code) {
+    const mappedSpan = mapUtf8UnitsToUtf16Units([span.start, span.end], code);
+    span.start = mappedSpan[span.start];
+    span.end = mappedSpan[span.end];
+}

package/dist/language-service/worker-proxy.js

@@ -4,7 +4,9 @@ import { createDispatcher, createProxy, } from "../worker-proxy.js";
 const requests = {
     updateConfiguration: "request",
     updateDocument: "request",
+    updateNotebookDocument: "request",
     closeDocument: "request",
+    closeNotebookDocument: "request",
     getCompletions: "request",
     getHover: "request",
     getDefinition: "request",