qsharp-lang 1.1.4-dev → 1.1.6-dev

package/dist/browser.d.ts

@@ -11,13 +11,13 @@ export declare function getDebugService(): Promise<IDebugService>;
 export declare function getProjectLoader(readFile: (path: string) => Promise<string | null>, loadDirectory: (path: string) => Promise<[string, number][]>, getManifest: (path: string) => Promise<{
     manifestDirectory: string;
 } | null>): Promise<wasm.ProjectLoader>;
-export declare function getDebugServiceWorker(workerArg: string | Worker): IDebugServiceWorker;
+export declare function getDebugServiceWorker(worker: string | Worker): IDebugServiceWorker;
 export declare function getCompiler(): Promise<ICompiler>;
-export declare function getCompilerWorker(workerArg: string | Worker): ICompilerWorker;
+export declare function getCompilerWorker(worker: string | Worker): ICompilerWorker;
 export declare function getLanguageService(readFile?: (uri: string) => Promise<string | null>, listDir?: (uri: string) => Promise<[string, number][]>, getManifest?: (uri: string) => Promise<{
     manifestDirectory: string;
 } | null>): Promise<ILanguageService>;
-export declare function getLanguageServiceWorker(workerArg: string | Worker): ILanguageServiceWorker;
+export declare function getLanguageServiceWorker(worker: string | Worker): ILanguageServiceWorker;
 export { type Dump, type ShotResult } from "./compiler/common.js";
 export { type CompilerState } from "./compiler/compiler.js";
 export { QscEventTarget } from "./compiler/events.js";

package/dist/browser.js

@@ -2,14 +2,13 @@
 // Licensed under the MIT License.
 // This module is the entry point for browser environments. For Node.js environment,
 // the "./main.js" module is the entry point.
-import initWasm, * as wasm from "../lib/web/qsc_wasm.js";
-import { Compiler } from "./compiler/compiler.js";
-import { createCompilerProxy } from "./compiler/worker-proxy.js";
-import { QSharpDebugService, } from "./debug-service/debug-service.js";
-import { createDebugServiceProxy } from "./debug-service/worker-proxy.js";
-import { QSharpLanguageService, qsharpLibraryUriScheme, } from "./language-service/language-service.js";
-import { createLanguageServiceProxy } from "./language-service/worker-proxy.js";
+import * as wasm from "../lib/web/qsc_wasm.js";
+import initWasm from "../lib/web/qsc_wasm.js";
+import { Compiler, compilerProtocol, } from "./compiler/compiler.js";
+import { QSharpDebugService, debugServiceProtocol, } from "./debug-service/debug-service.js";
+import { QSharpLanguageService, languageServiceProtocol, qsharpLibraryUriScheme, } from "./language-service/language-service.js";
 import { log } from "./log.js";
+import { createProxy } from "./workers/browser.js";
 export { qsharpLibraryUriScheme };
 // Create once. A module is stateless and can be efficiently passed to WebWorkers.
 let wasmModule = null;
@@ -79,25 +78,10 @@ export async function getProjectLoader(readFile, loadDirectory, getManifest) {
 // Create the debugger inside a WebWorker and proxy requests.
 // If the Worker was already created via other means and is ready to receive
 // messages, then the worker may be passed in and it will be initialized.
-export function getDebugServiceWorker(workerArg) {
+export function getDebugServiceWorker(worker) {
     if (!wasmModule)
         throw "Wasm module must be loaded first";
-    // Create or use the WebWorker
-    const worker = typeof workerArg === "string" ? new Worker(workerArg) : workerArg;
-    // Send it the Wasm module to instantiate
-    worker.postMessage({
-        type: "init",
-        wasmModule,
-        qscLogLevel: log.getLogLevel(),
-    });
-    // If you lose the 'this' binding, some environments have issues
-    const postMessage = worker.postMessage.bind(worker);
-    const onTerminate = () => worker.terminate();
-    // Create the proxy which will forward method calls to the worker
-    const proxy = createDebugServiceProxy(postMessage, onTerminate);
-    // Let proxy handle response and event messages from the worker
-    worker.onmessage = (ev) => proxy.onMsgFromWorker(ev.data);
-    return proxy;
+    return createProxy(worker, wasmModule, debugServiceProtocol);
 }
 export async function getCompiler() {
     await instantiateWasm();
@@ -106,25 +90,10 @@ export async function getCompiler() {
 // Create the compiler inside a WebWorker and proxy requests.
 // If the Worker was already created via other means and is ready to receive
 // messages, then the worker may be passed in and it will be initialized.
-export function getCompilerWorker(workerArg) {
+export function getCompilerWorker(worker) {
     if (!wasmModule)
         throw "Wasm module must be loaded first";
-    // Create or use the WebWorker
-    const worker = typeof workerArg === "string" ? new Worker(workerArg) : workerArg;
-    // Send it the Wasm module to instantiate
-    worker.postMessage({
-        type: "init",
-        wasmModule,
-        qscLogLevel: log.getLogLevel(),
-    });
-    // If you lose the 'this' binding, some environments have issues
-    const postMessage = worker.postMessage.bind(worker);
-    const onTerminate = () => worker.terminate();
-    // Create the proxy which will forward method calls to the worker
-    const proxy = createCompilerProxy(postMessage, onTerminate);
-    // Let proxy handle response and event messages from the worker
-    worker.onmessage = (ev) => proxy.onMsgFromWorker(ev.data);
-    return proxy;
+    return createProxy(worker, wasmModule, compilerProtocol);
 }
 export async function getLanguageService(readFile, listDir, getManifest) {
     await instantiateWasm();
@@ -133,25 +102,10 @@ export async function getLanguageService(readFile, listDir, getManifest) {
 // Create the compiler inside a WebWorker and proxy requests.
 // If the Worker was already created via other means and is ready to receive
 // messages, then the worker may be passed in and it will be initialized.
-export function getLanguageServiceWorker(workerArg) {
+export function getLanguageServiceWorker(worker) {
     if (!wasmModule)
         throw "Wasm module must be loaded first";
-    // Create or use the WebWorker
-    const worker = typeof workerArg === "string" ? new Worker(workerArg) : workerArg;
-    // Send it the Wasm module to instantiate
-    worker.postMessage({
-        type: "init",
-        wasmModule,
-        qscLogLevel: log.getLogLevel(),
-    });
-    // If you lose the 'this' binding, some environments have issues
-    const postMessage = worker.postMessage.bind(worker);
-    const onTerminate = () => worker.terminate();
-    // Create the proxy which will forward method calls to the worker
-    const proxy = createLanguageServiceProxy(postMessage, onTerminate);
-    // Let proxy handle response and event messages from the worker
-    worker.onmessage = (ev) => proxy.onMsgFromWorker(ev.data);
-    return proxy;
+    return createProxy(worker, wasmModule, languageServiceProtocol);
 }
 export { QscEventTarget } from "./compiler/events.js";
 export { getAllKatas, getExerciseSources, getKata, } from "./katas.js";

package/dist/compiler/compiler.d.ts

@@ -1,26 +1,46 @@
 import { type VSDiagnostic } from "../../lib/web/qsc_wasm.js";
-import { IServiceProxy, ServiceState } from "../worker-proxy.js";
-import { IQscEventTarget } from "./events.js";
+import { IServiceProxy, ServiceProtocol, ServiceState } from "../workers/common.js";
+import { IQscEventTarget, QscEventData } from "./events.js";
 type Wasm = typeof import("../../lib/node/qsc_wasm.cjs");
 export interface ICompiler {
     checkCode(code: string): Promise<VSDiagnostic[]>;
-    getHir(code: string): Promise<string>;
+    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
+     * 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
+     * the new API.
+     **/
     run(sources: [string, string][], expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
-    getQir(sources: [string, string][]): Promise<string>;
-    getEstimates(sources: [string, string][], params: string): Promise<string>;
+    run(config: ProgramConfig, eventHandler: IQscEventTarget): Promise<void>;
+    getQir(sources: [string, string][], languageFeatures?: string[]): Promise<string>;
+    getEstimates(sources: [string, string][], params: string, languageFeatures?: string[]): Promise<string>;
     checkExerciseSolution(user_code: string, exercise_sources: 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[];
+};
 export type ICompilerWorker = ICompiler & IServiceProxy;
 export type CompilerState = ServiceState;
 export declare class Compiler implements ICompiler {
     private wasm;
     constructor(wasm: Wasm);
     checkCode(code: string): Promise<VSDiagnostic[]>;
-    getQir(sources: [string, string][]): Promise<string>;
-    getEstimates(sources: [string, string][], params: string): Promise<string>;
-    getHir(code: string): Promise<string>;
-    run(sources: [string, string][], expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
+    getQir(sources: [string, string][], languageFeatures: string[]): Promise<string>;
+    getEstimates(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>;
 }
 export declare function onCompilerEvent(msg: string, eventTarget: IQscEventTarget): void;
+/** The protocol definition to allow running the compiler in a worker. */
+export declare const compilerProtocol: ServiceProtocol<ICompiler, QscEventData>;
 export {};

package/dist/compiler/compiler.js

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 import { log } from "../log.js";
 import { eventStringToMsg } from "./common.js";
-import { makeEvent } from "./events.js";
+import { makeEvent, } from "./events.js";
 export class Compiler {
     constructor(wasm) {
         log.info("Constructing a Compiler instance");
@@ -25,20 +25,40 @@ export class Compiler {
         languageService.free();
         return diags;
     }
-    async getQir(sources) {
-        return this.wasm.get_qir(sources);
+    async getQir(sources, languageFeatures) {
+        return this.wasm.get_qir(sources, languageFeatures);
     }
-    async getEstimates(sources, params) {
-        return this.wasm.get_estimates(sources, params);
+    async getEstimates(sources, params, languageFeatures) {
+        return this.wasm.get_estimates(sources, params, languageFeatures);
     }
-    async getHir(code) {
-        return this.wasm.get_hir(code);
+    async getHir(code, languageFeatures) {
+        return this.wasm.get_hir(code, languageFeatures);
     }
-    async run(sources, expr, shots, eventHandler) {
+    async run(sourcesOrConfig, exprOrEventHandler, maybeShots, maybeEventHandler) {
+        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
         // entry expression or similar), it may throw on run. The caller should expect this promise
         // may reject without all shots running or events firing.
-        this.wasm.run(sources, expr, (msg) => onCompilerEvent(msg, eventHandler), shots);
+        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));
@@ -70,3 +90,16 @@ export function onCompilerEvent(msg, eventTarget) {
     log.debug("worker dispatching event " + JSON.stringify(qscEvent));
     eventTarget.dispatchEvent(qscEvent);
 }
+/** The protocol definition to allow running the compiler in a worker. */
+export const compilerProtocol = {
+    class: Compiler,
+    methods: {
+        checkCode: "request",
+        getHir: "request",
+        getQir: "request",
+        getEstimates: "request",
+        run: "requestWithProgress",
+        checkExerciseSolution: "requestWithProgress",
+    },
+    eventNames: ["DumpMachine", "Message", "Result"],
+};

package/dist/compiler/events.d.ts

@@ -1,6 +1,6 @@
 import { ShotResult, Dump, Result } from "./common.js";
 import { TelemetryEvent } from "../log.js";
-import { IServiceEventTarget } from "../worker-proxy.js";
+import { IServiceEventTarget } from "../workers/common.js";
 export type QscEventData = {
     type: "Message";
     detail: string;

package/dist/compiler/worker-browser.d.ts

@@ -1 +1 @@
-export declare function messageHandler(e: MessageEvent): void;
+export declare const messageHandler: (e: MessageEvent<any>) => void;

package/dist/compiler/worker-browser.js

@@ -1,43 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import * as wasm from "../../lib/web/qsc_wasm.js";
-import { log } from "../log.js";
-import { Compiler } from "./compiler.js";
-import { createCompilerDispatcher } from "./worker-proxy.js";
-let invokeCompiler = null;
-function telemetryHandler(telemetry) {
-    self.postMessage({
-        messageType: "event",
-        type: "telemetry-event",
-        detail: telemetry,
-    });
-}
+import { createWorker } from "../workers/browser.js";
+import { compilerProtocol } from "./compiler.js";
 // This export should be assigned to 'self.onmessage' in a WebWorker
-export function messageHandler(e) {
-    const data = e.data;
-    if (!data.type || typeof data.type !== "string") {
-        log.error(`Unrecognized msg: ${data}`);
-        return;
-    }
-    switch (data.type) {
-        case "init":
-            {
-                log.setLogLevel(data.qscLogLevel);
-                log.setTelemetryCollector(telemetryHandler);
-                wasm.initSync(data.wasmModule);
-                // Set up logging and telemetry as soon as possible after instantiating
-                wasm.initLogging(log.logWithLevel, log.getLogLevel());
-                log.onLevelChanged = (level) => wasm.setLogLevel(level);
-                const compiler = new Compiler(wasm);
-                invokeCompiler = createCompilerDispatcher(self.postMessage.bind(self), compiler);
-            }
-            break;
-        default:
-            if (!invokeCompiler) {
-                log.error(`Received message before the compiler was initialized: %o`, data);
-            }
-            else {
-                invokeCompiler(data);
-            }
-    }
-}
+export const messageHandler = createWorker(compilerProtocol);

package/dist/compiler/worker-node.js

@@ -1,41 +1,5 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-// This module supports running the qsharp compiler in a Node.js worker thread. It should be
-// used in a Node.js module in a manner similar to the below to create it with the right log level:
-//
-//     const worker = new Worker(join(thisDir,"worker-node.js"), {
-//         workerData: {qscLogLevel: log.getLogLevel() }
-//     });
-import { isMainThread, parentPort, workerData } from "node:worker_threads";
-import * as wasm from "../../lib/node/qsc_wasm.cjs";
-import { log } from "../log.js";
-import { Compiler } from "./compiler.js";
-import { createCompilerDispatcher } from "./worker-proxy.js";
-if (isMainThread)
-    throw "Worker script should be loaded in a Worker thread only";
-if (workerData && typeof workerData.qscLogLevel === "number") {
-    log.setLogLevel(workerData.qscLogLevel);
-}
-const port = parentPort; // eslint-disable-line @typescript-eslint/no-non-null-assertion
-const postMessage = port.postMessage.bind(port);
-function telemetryHandler(telemetry) {
-    postMessage({
-        messageType: "event",
-        type: "telemetry-event",
-        detail: telemetry,
-    });
-}
-// Set up logging and telemetry as soon as possible after instantiating
-log.onLevelChanged = (level) => wasm.setLogLevel(level);
-log.setTelemetryCollector(telemetryHandler);
-wasm.initLogging(log.logWithLevel, log.getLogLevel());
-const compiler = new Compiler(wasm);
-const invokeCompiler = createCompilerDispatcher(postMessage, compiler);
-function messageHandler(data) {
-    if (!data.type || typeof data.type !== "string") {
-        log.error(`Unrecognized msg: %O"`, data);
-        return;
-    }
-    invokeCompiler(data);
-}
-port.addListener("message", messageHandler);
+import { createWorker } from "../workers/node.js";
+import { compilerProtocol } from "./compiler.js";
+createWorker(compilerProtocol);

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

@@ -1,10 +1,10 @@
-import type { IBreakpointSpan, IStackFrame, IStructStepResult, IVariable, IQuantumState } from "../../lib/node/qsc_wasm.cjs";
+import type { IBreakpointSpan, IQuantumState, IStackFrame, IStructStepResult, IVariable } from "../../lib/node/qsc_wasm.cjs";
 import { TargetProfile } from "../browser.js";
-import { IQscEventTarget } from "../compiler/events.js";
-import { IServiceProxy } from "../worker-proxy.js";
+import { IQscEventTarget, QscEventData } from "../compiler/events.js";
+import { IServiceProxy, ServiceProtocol } from "../workers/common.js";
 type QscWasm = typeof import("../../lib/node/qsc_wasm.cjs");
 export interface IDebugService {
-    loadSource(sources: [string, string][], target: TargetProfile, entry: string | undefined): Promise<string>;
+    loadSource(sources: [string, string][], target: TargetProfile, entry: string | undefined, language_features: string[]): 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 wasm;
     private debugService;
     constructor(wasm: QscWasm);
-    loadSource(sources: [string, string][], target: TargetProfile, entry: string | undefined): Promise<string>;
+    loadSource(sources: [string, string][], target: TargetProfile, entry: string | undefined, language_features: string[]): Promise<string>;
     getStackFrames(): Promise<IStackFrame[]>;
     evalNext(bps: number[], eventHandler: IQscEventTarget): Promise<IStructStepResult>;
     evalStepIn(bps: number[], eventHandler: IQscEventTarget): Promise<IStructStepResult>;
@@ -32,4 +32,6 @@ export declare class QSharpDebugService implements IDebugService {
     dispose(): Promise<void>;
 }
 export declare function onCompilerEvent(msg: string, eventTarget: IQscEventTarget): void;
+/** The protocol definition to allow running the debugger in a worker. */
+export declare const debugServiceProtocol: ServiceProtocol<IDebugService, QscEventData>;
 export {};

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

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 import { eventStringToMsg } from "../compiler/common.js";
-import { makeEvent } from "../compiler/events.js";
+import { makeEvent, } from "../compiler/events.js";
 import { log } from "../log.js";
 export class QSharpDebugService {
     constructor(wasm) {
@@ -9,8 +9,8 @@ export class QSharpDebugService {
         this.wasm = wasm;
         this.debugService = new wasm.DebugService();
     }
-    async loadSource(sources, target, entry) {
-        return this.debugService.load_source(sources, target, entry);
+    async loadSource(sources, target, entry, language_features) {
+        return this.debugService.load_source(sources, target, entry, language_features);
     }
     async getStackFrames() {
         return this.debugService.get_stack_frames().frames;
@@ -75,3 +75,20 @@ export function onCompilerEvent(msg, eventTarget) {
     log.debug("worker dispatching event " + JSON.stringify(qscEvent));
     eventTarget.dispatchEvent(qscEvent);
 }
+/** The protocol definition to allow running the debugger in a worker. */
+export const debugServiceProtocol = {
+    class: QSharpDebugService,
+    methods: {
+        loadSource: "request",
+        getBreakpoints: "request",
+        getLocalVariables: "request",
+        captureQuantumState: "request",
+        getStackFrames: "request",
+        evalContinue: "requestWithProgress",
+        evalNext: "requestWithProgress",
+        evalStepIn: "requestWithProgress",
+        evalStepOut: "requestWithProgress",
+        dispose: "request",
+    },
+    eventNames: ["DumpMachine", "Message", "Result"],
+};

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

@@ -1 +1 @@
-export declare function messageHandler(e: MessageEvent): void;
+export declare const messageHandler: (e: MessageEvent<any>) => void;

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

@@ -1,32 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import * as wasm from "../../lib/web/qsc_wasm.js";
-import { log } from "../log.js";
-import { QSharpDebugService } from "./debug-service.js";
-import { createDebugServiceDispatcher } from "./worker-proxy.js";
-let invokeDebugger = null;
+import { createWorker } from "../workers/browser.js";
+import { debugServiceProtocol } from "./debug-service.js";
 // This export should be assigned to 'self.onmessage' in a WebWorker
-export function messageHandler(e) {
-    const data = e.data;
-    if (!data.type || typeof data.type !== "string") {
-        log.error(`Unrecognized msg: ${data}`);
-        return;
-    }
-    switch (data.type) {
-        case "init":
-            {
-                log.setLogLevel(data.qscLogLevel);
-                wasm.initSync(data.wasmModule);
-                const debugService = new QSharpDebugService(wasm);
-                invokeDebugger = createDebugServiceDispatcher(self.postMessage.bind(self), debugService);
-            }
-            break;
-        default:
-            if (!invokeDebugger) {
-                log.error(`Received message before the debugger was initialized: %o`, data);
-            }
-            else {
-                invokeDebugger(data);
-            }
-    }
-}
+export const messageHandler = createWorker(debugServiceProtocol);

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

@@ -1,30 +1,5 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-// This module supports running the qsharp debugger in a Node.js worker thread. It should be
-// used in a Node.js module in a manner similar to the below to create it with the right log level:
-//
-//     const worker = new Worker(join(thisDir,"worker-node.js"), {
-//         workerData: {qscLogLevel: log.getLogLevel() }
-//     });
-import { isMainThread, parentPort, workerData } from "node:worker_threads";
-import * as wasm from "../../lib/node/qsc_wasm.cjs";
-import { log } from "../log.js";
-import { QSharpDebugService } from "./debug-service.js";
-import { createDebugServiceDispatcher } from "./worker-proxy.js";
-if (isMainThread)
-    throw "Worker script should be loaded in a Worker thread only";
-if (workerData && typeof workerData.qscLogLevel === "number") {
-    log.setLogLevel(workerData.qscLogLevel);
-}
-const port = parentPort; // eslint-disable-line @typescript-eslint/no-non-null-assertion
-const postMessage = port.postMessage.bind(port);
-const debuggerd = new QSharpDebugService(wasm);
-const invokeDebugger = createDebugServiceDispatcher(postMessage, debuggerd);
-function messageHandler(data) {
-    if (!data.type || typeof data.type !== "string") {
-        log.error(`Unrecognized msg: %O"`, data);
-        return;
-    }
-    invokeDebugger(data);
-}
-port.addListener("message", messageHandler);
+import { createWorker } from "../workers/node.js";
+import { debugServiceProtocol } from "./debug-service.js";
+createWorker(debugServiceProtocol);