qsharp-lang 1.1.6-dev → 1.2.1-dev

package/dist/compiler/common.d.ts

@@ -12,6 +12,7 @@ export type Result = {
 interface DumpMsg {
     type: "DumpMachine";
     state: Dump;
+    stateLatex: string;
 }
 interface MessageMsg {
     type: "Message";

package/dist/compiler/compiler.d.ts

@@ -6,25 +6,35 @@ export interface ICompiler {
     checkCode(code: string): Promise<VSDiagnostic[]>;
     getHir(code: string, languageFeatures?: string[]): Promise<string>;
     /** @deprecated -- switch to using `ProgramConfig`-based overload. Instead of passing
-     * all arguments separately, pass an object with named properties. This change was made
+     * sources and language features separately, pass an object with named properties. This change was made
      * for the sake of extensibility and future-compatibility. Note that only the new API
-     * supports passing guage features. If you need to pass language features, you must use
+     * supports passing language features. If you need to pass language features, you must use
      * the new API.
      **/
     run(sources: [string, string][], expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
-    run(config: ProgramConfig, eventHandler: IQscEventTarget): Promise<void>;
+    run(config: ProgramConfig, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
+    /** @deprecated -- switch to using `ProgramConfig`-based overload. Instead of passing
+     * sources and language features separately, pass an object with named properties. This change was made
+     * for the sake of extensibility and future-compatibility. Note that only the new API
+     * supports passing language features. If you need to pass language features, you must use
+     * the new API.
+     **/
     getQir(sources: [string, string][], languageFeatures?: string[]): Promise<string>;
+    getQir(config: ProgramConfig): Promise<string>;
+    /** @deprecated -- switch to using `ProgramConfig`-based overload. Instead of passing
+     * sources and language features separately, pass an object with named properties. This change was made
+     * for the sake of extensibility and future-compatibility. Note that only the new API
+     * supports passing language features. If you need to pass language features, you must use
+     * the new API.
+     **/
     getEstimates(sources: [string, string][], params: string, languageFeatures?: string[]): Promise<string>;
-    checkExerciseSolution(user_code: string, exercise_sources: string[], eventHandler: IQscEventTarget): Promise<boolean>;
+    getEstimates(config: ProgramConfig, params: string): Promise<string>;
+    checkExerciseSolution(userCode: string, exerciseSources: string[], eventHandler: IQscEventTarget): Promise<boolean>;
 }
 /** Type definition for the configuration of a program. */
 export type ProgramConfig = {
     /** An array of source objects, each containing a name and contents. */
     sources: [string, string][];
-    /** The entry expression to be evaluated. */
-    expr: string;
-    /** The number of shots to be performed in the quantum simulation. */
-    shots: number;
     /** An array of language features to be opted in to in this compilation. */
     languageFeatures?: string[];
 };
@@ -34,11 +44,15 @@ export declare class Compiler implements ICompiler {
     private wasm;
     constructor(wasm: Wasm);
     checkCode(code: string): Promise<VSDiagnostic[]>;
-    getQir(sources: [string, string][], languageFeatures: string[]): Promise<string>;
-    getEstimates(sources: [string, string][], params: string, languageFeatures: string[]): Promise<string>;
+    getQir(sourcesOrConfig: [string, string][] | ProgramConfig, languageFeatures?: string[]): Promise<string>;
+    newGetQir({ sources, languageFeatures, }: ProgramConfig): Promise<string>;
+    deprecatedGetQir(sources: [string, string][], languageFeatures: string[]): Promise<string>;
+    getEstimates(sourcesOrConfig: [string, string][] | ProgramConfig, params: string, languageFeatures?: string[]): Promise<string>;
+    newGetEstimates({ sources, languageFeatures }: ProgramConfig, params: string): Promise<string>;
+    deprecatedGetEstimates(sources: [string, string][], params: string, languageFeatures: string[]): Promise<string>;
     getHir(code: string, languageFeatures: string[]): Promise<string>;
-    run(sourcesOrConfig: [string, string][] | ProgramConfig, exprOrEventHandler: string | IQscEventTarget, maybeShots?: number, maybeEventHandler?: IQscEventTarget): Promise<void>;
-    checkExerciseSolution(user_code: string, exercise_sources: string[], eventHandler: IQscEventTarget): Promise<boolean>;
+    run(sourcesOrConfig: [string, string][] | ProgramConfig, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
+    checkExerciseSolution(userCode: string, exerciseSources: string[], eventHandler: IQscEventTarget): Promise<boolean>;
 }
 export declare function onCompilerEvent(msg: string, eventTarget: IQscEventTarget): void;
 /** The protocol definition to allow running the compiler in a worker. */

package/dist/compiler/compiler.js

@@ -25,34 +25,47 @@ export class Compiler {
         languageService.free();
         return diags;
     }
-    async getQir(sources, languageFeatures) {
+    async getQir(sourcesOrConfig, languageFeatures) {
+        if (Array.isArray(sourcesOrConfig)) {
+            return this.deprecatedGetQir(sourcesOrConfig, languageFeatures || []);
+        }
+        else {
+            return this.newGetQir(sourcesOrConfig);
+        }
+    }
+    async newGetQir({ sources, languageFeatures = [], }) {
+        return this.wasm.get_qir(sources, languageFeatures);
+    }
+    async deprecatedGetQir(sources, languageFeatures) {
         return this.wasm.get_qir(sources, languageFeatures);
     }
-    async getEstimates(sources, params, languageFeatures) {
+    async getEstimates(sourcesOrConfig, params, languageFeatures = []) {
+        if (Array.isArray(sourcesOrConfig)) {
+            return this.deprecatedGetEstimates(sourcesOrConfig, params, languageFeatures);
+        }
+        else {
+            return this.newGetEstimates(sourcesOrConfig, params);
+        }
+    }
+    async newGetEstimates({ sources, languageFeatures }, params) {
+        return this.wasm.get_estimates(sources, params, languageFeatures || []);
+    }
+    async deprecatedGetEstimates(sources, params, languageFeatures) {
         return this.wasm.get_estimates(sources, params, languageFeatures);
     }
     async getHir(code, languageFeatures) {
         return this.wasm.get_hir(code, languageFeatures);
     }
-    async run(sourcesOrConfig, exprOrEventHandler, maybeShots, maybeEventHandler) {
+    async run(sourcesOrConfig, expr, shots, eventHandler) {
         let sources;
-        let expr;
-        let shots;
-        let eventHandler;
         let languageFeatures = [];
         if (Array.isArray(sourcesOrConfig)) {
             // this is the deprecated API
             sources = sourcesOrConfig;
-            expr = exprOrEventHandler;
-            shots = maybeShots;
-            eventHandler = maybeEventHandler;
         }
         else {
             // this is the new API
             sources = sourcesOrConfig.sources;
-            expr = sourcesOrConfig.expr;
-            shots = sourcesOrConfig.shots;
-            eventHandler = exprOrEventHandler;
             languageFeatures = sourcesOrConfig.languageFeatures || [];
         }
         // All results are communicated as events, but if there is a compiler error (e.g. an invalid
@@ -60,8 +73,8 @@ export class Compiler {
         // may reject without all shots running or events firing.
         this.wasm.run(sources, expr, (msg) => onCompilerEvent(msg, eventHandler), shots, languageFeatures);
     }
-    async checkExerciseSolution(user_code, exercise_sources, eventHandler) {
-        const success = this.wasm.check_exercise_solution(user_code, exercise_sources, (msg) => onCompilerEvent(msg, eventHandler));
+    async checkExerciseSolution(userCode, exerciseSources, eventHandler) {
+        const success = this.wasm.check_exercise_solution(userCode, exerciseSources, (msg) => onCompilerEvent(msg, eventHandler));
         return success;
     }
 }
@@ -78,7 +91,10 @@ export function onCompilerEvent(msg, eventTarget) {
             qscEvent = makeEvent("Message", qscMsg.message);
             break;
         case "DumpMachine":
-            qscEvent = makeEvent("DumpMachine", qscMsg.state);
+            qscEvent = makeEvent("DumpMachine", {
+                state: qscMsg.state,
+                stateLatex: qscMsg.stateLatex,
+            });
             break;
         case "Result":
             qscEvent = makeEvent("Result", qscMsg.result);

package/dist/compiler/events.d.ts

@@ -1,18 +1,17 @@
 import { ShotResult, Dump, Result } from "./common.js";
-import { TelemetryEvent } from "../log.js";
 import { IServiceEventTarget } from "../workers/common.js";
 export type QscEventData = {
     type: "Message";
     detail: string;
 } | {
     type: "DumpMachine";
-    detail: Dump;
+    detail: {
+        state: Dump;
+        stateLatex: string;
+    };
 } | {
     type: "Result";
     detail: Result;
-} | {
-    type: "telemetry-event";
-    detail: TelemetryEvent;
 };
 export type QscEvents = Event & QscEventData;
 export type QscEvent<T extends QscEvents["type"]> = Extract<QscEvents, {

package/dist/compiler/events.js

@@ -43,10 +43,14 @@ export class QscEventTarget {
         this.results[shotIdx].events.push({ type: "Message", message: msg });
         this.queueUiRefresh();
     }
-    onDumpMachine(dump) {
+    onDumpMachine(detail) {
         this.ensureActiveShot();
         const shotIdx = this.results.length - 1;
-        this.results[shotIdx].events.push({ type: "DumpMachine", state: dump });
+        this.results[shotIdx].events.push({
+            type: "DumpMachine",
+            state: detail.state,
+            stateLatex: detail.stateLatex,
+        });
         this.queueUiRefresh();
     }
     onResult(result) {

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

@@ -63,7 +63,10 @@ export function onCompilerEvent(msg, eventTarget) {
             qscEvent = makeEvent("Message", qscMsg.message);
             break;
         case "DumpMachine":
-            qscEvent = makeEvent("DumpMachine", qscMsg.state);
+            qscEvent = makeEvent("DumpMachine", {
+                state: qscMsg.state,
+                stateLatex: qscMsg.stateLatex,
+            });
             break;
         case "Result":
             qscEvent = makeEvent("Result", qscMsg.result);