qsharp-lang 0.1.0-dev.1

package/dist/compiler/worker-browser.js

@@ -0,0 +1,43 @@
+// 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,
+    });
+}
+// 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);
+            }
+    }
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/compiler/worker-node.js

@@ -0,0 +1,41 @@
+// 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);

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

@@ -0,0 +1,7 @@
+import { EventMessage, RequestMessage, ResponseMessage } from "../worker-proxy.js";
+import { ICompiler } from "./compiler.js";
+import { QscEventData } from "./events.js";
+export declare function createCompilerDispatcher(postMessage: (msg: ResponseMessage<ICompiler> | EventMessage<QscEventData>) => void, service: ICompiler): (req: RequestMessage<ICompiler>) => any;
+export declare function createCompilerProxy(postMessage: (msg: RequestMessage<ICompiler>) => void, terminator: () => void): ICompiler & import("../worker-proxy.js").IServiceProxy & {
+    onMsgFromWorker: (msg: ResponseMessage<ICompiler> | EventMessage<QscEventData>) => void;
+};

package/dist/compiler/worker-proxy.js

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { createDispatcher, createProxy, } from "../worker-proxy.js";
+const requests = {
+    checkCode: "request",
+    getHir: "request",
+    run: "requestWithProgress",
+    checkExerciseSolution: "requestWithProgress",
+};
+const events = ["DumpMachine", "Message", "Result"];
+export function createCompilerDispatcher(postMessage, service) {
+    return createDispatcher(postMessage, service, requests, events);
+}
+export function createCompilerProxy(postMessage, terminator) {
+    return createProxy(postMessage, terminator, requests);
+}

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

@@ -0,0 +1,35 @@
+import type { IBreakpointSpan, IStackFrame, IStructStepResult, IVariable, IQuantumState } from "../../lib/node/qsc_wasm.cjs";
+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>;
+    getBreakpoints(path: string): Promise<IBreakpointSpan[]>;
+    getLocalVariables(): Promise<Array<IVariable>>;
+    captureQuantumState(): Promise<Array<IQuantumState>>;
+    getStackFrames(): Promise<IStackFrame[]>;
+    evalContinue(bps: number[], eventHandler: IQscEventTarget): Promise<IStructStepResult>;
+    evalNext(bps: number[], eventHandler: IQscEventTarget): Promise<IStructStepResult>;
+    evalStepIn(bps: number[], eventHandler: IQscEventTarget): Promise<IStructStepResult>;
+    evalStepOut(bps: number[], eventHandler: IQscEventTarget): Promise<IStructStepResult>;
+    dispose(): Promise<void>;
+}
+export type IDebugServiceWorker = IDebugService & IServiceProxy;
+export declare class QSharpDebugService implements IDebugService {
+    private wasm;
+    private debugService;
+    private code;
+    constructor(wasm: QscWasm);
+    loadSource(path: string, source: string, entry: string | undefined): Promise<string>;
+    getStackFrames(): Promise<IStackFrame[]>;
+    evalNext(bps: number[], eventHandler: IQscEventTarget): Promise<IStructStepResult>;
+    evalStepIn(bps: number[], eventHandler: IQscEventTarget): Promise<IStructStepResult>;
+    evalStepOut(bps: number[], eventHandler: IQscEventTarget): Promise<IStructStepResult>;
+    evalContinue(bps: number[], eventHandler: IQscEventTarget): Promise<IStructStepResult>;
+    getBreakpoints(path: string): Promise<IBreakpointSpan[]>;
+    captureQuantumState(): Promise<Array<IQuantumState>>;
+    getLocalVariables(): Promise<Array<IVariable>>;
+    dispose(): Promise<void>;
+}
+export declare function onCompilerEvent(msg: string, eventTarget: IQscEventTarget): void;
+export {};

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

@@ -0,0 +1,136 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { eventStringToMsg } from "../compiler/common.js";
+import { makeEvent } from "../compiler/events.js";
+import { log } from "../log.js";
+import { mapUtf8UnitsToUtf16Units } from "../vsdiagnostic.js";
+export class QSharpDebugService {
+    constructor(wasm) {
+        // We need to keep a copy of the code for mapping diagnostics to utf16 offsets
+        this.code = {};
+        log.info("Constructing a QSharpDebugService instance");
+        this.wasm = wasm;
+        this.debugService = new wasm.DebugService();
+    }
+    async loadSource(path, source, entry) {
+        this.code[path] = source;
+        return this.debugService.load_source(path, source, entry);
+    }
+    async getStackFrames() {
+        const stack_frame_list = this.debugService.get_stack_frames();
+        const stack_frames = await Promise.all(stack_frame_list.frames.map(async (frame) => {
+            // get any missing sources if possible
+            if (!(frame.path in this.code)) {
+                const content = await this.wasm.get_library_source_content(frame.path);
+                if (content) {
+                    this.code[frame.path] = content;
+                }
+            }
+            if (frame.path in this.code) {
+                const mappedSpan = mapUtf8UnitsToUtf16Units([frame.lo, frame.hi], this.code[frame.path]);
+                return {
+                    ...frame,
+                    lo: mappedSpan[frame.lo],
+                    hi: mappedSpan[frame.hi],
+                };
+            }
+            else {
+                // We don't have a source file for this frame,
+                // and we couldn't load it, so just return it as-is
+                return frame;
+            }
+        }));
+        return stack_frames;
+    }
+    async evalNext(bps, eventHandler) {
+        const event_cb = (msg) => onCompilerEvent(msg, eventHandler);
+        const ids = new Uint32Array(bps);
+        const result = this.debugService.eval_next(event_cb, ids);
+        return { id: result.id, value: result.value };
+    }
+    async evalStepIn(bps, eventHandler) {
+        const event_cb = (msg) => onCompilerEvent(msg, eventHandler);
+        const ids = new Uint32Array(bps);
+        const result = this.debugService.eval_step_in(event_cb, ids);
+        return { id: result.id, value: result.value };
+    }
+    async evalStepOut(bps, eventHandler) {
+        const event_cb = (msg) => onCompilerEvent(msg, eventHandler);
+        const ids = new Uint32Array(bps);
+        const result = this.debugService.eval_step_out(event_cb, ids);
+        return { id: result.id, value: result.value };
+    }
+    async evalContinue(bps, eventHandler) {
+        const event_cb = (msg) => onCompilerEvent(msg, eventHandler);
+        const ids = new Uint32Array(bps);
+        const result = this.debugService.eval_continue(event_cb, ids);
+        return { id: result.id, value: result.value };
+    }
+    async getBreakpoints(path) {
+        const breakpoint_list = this.debugService.get_breakpoints(path);
+        // Get a map of the Rust source positions to the JavaScript source positions
+        const positions = [];
+        breakpoint_list.spans.forEach((span) => {
+            positions.push(span.lo);
+            positions.push(span.hi);
+        });
+        const positionMap = mapUtf8UnitsToUtf16Units(positions, this.code[path]);
+        const breakpoint_spans = breakpoint_list.spans.map((span) => {
+            const result = {};
+            result.id = span.id;
+            result.lo = positionMap[span.lo];
+            result.hi = positionMap[span.hi];
+            return result;
+        });
+        return breakpoint_spans;
+    }
+    async captureQuantumState() {
+        const state = this.debugService.capture_quantum_state();
+        const entries = state.entries.map((entry) => {
+            const result = {};
+            result.name = entry.name;
+            result.value = entry.value;
+            return result;
+        });
+        return entries;
+    }
+    async getLocalVariables() {
+        const variable_list = this.debugService.get_locals();
+        const variables = variable_list.variables.map((variable) => {
+            const result = {};
+            result.name = variable.name;
+            result.value = variable.value;
+            result.var_type = variable.var_type;
+            return result;
+        });
+        return variables;
+    }
+    async dispose() {
+        this.debugService.free();
+    }
+}
+export function onCompilerEvent(msg, eventTarget) {
+    const qscMsg = eventStringToMsg(msg);
+    if (!qscMsg) {
+        log.error("Unknown event message: %s", msg);
+        return;
+    }
+    let qscEvent;
+    const msgType = qscMsg.type;
+    switch (msgType) {
+        case "Message":
+            qscEvent = makeEvent("Message", qscMsg.message);
+            break;
+        case "DumpMachine":
+            qscEvent = makeEvent("DumpMachine", qscMsg.state);
+            break;
+        case "Result":
+            qscEvent = makeEvent("Result", qscMsg.result);
+            break;
+        default:
+            log.never(msgType);
+            throw "Unexpected message type";
+    }
+    log.debug("worker dispatching event " + JSON.stringify(qscEvent));
+    eventTarget.dispatchEvent(qscEvent);
+}

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

@@ -0,0 +1 @@
+export declare function messageHandler(e: MessageEvent): void;

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

@@ -0,0 +1,32 @@
+// 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;
+// 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);
+            }
+    }
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,30 @@
+// 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);

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

@@ -0,0 +1,7 @@
+import { QscEventData } from "../compiler/events.js";
+import { EventMessage, RequestMessage, ResponseMessage } from "../worker-proxy.js";
+import { IDebugService } from "./debug-service.js";
+export declare function createDebugServiceDispatcher(postMessage: (msg: ResponseMessage<IDebugService> | EventMessage<QscEventData>) => void, service: IDebugService): (req: RequestMessage<IDebugService>) => any;
+export declare function createDebugServiceProxy(postMessage: (msg: RequestMessage<IDebugService>) => void, terminator: () => void): IDebugService & import("../worker-proxy.js").IServiceProxy & {
+    onMsgFromWorker: (msg: EventMessage<QscEventData> | ResponseMessage<IDebugService>) => void;
+};

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

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { createDispatcher, createProxy, } from "../worker-proxy.js";
+const requests = {
+    loadSource: "request",
+    getBreakpoints: "request",
+    getLocalVariables: "request",
+    captureQuantumState: "request",
+    getStackFrames: "request",
+    evalContinue: "requestWithProgress",
+    evalNext: "requestWithProgress",
+    evalStepIn: "requestWithProgress",
+    evalStepOut: "requestWithProgress",
+    dispose: "request",
+};
+const events = ["DumpMachine", "Message", "Result"];
+export function createDebugServiceDispatcher(postMessage, service) {
+    return createDispatcher(postMessage, service, requests, events);
+}
+export function createDebugServiceProxy(postMessage, terminator) {
+    return createProxy(postMessage, terminator, requests);
+}

package/dist/katas-content.generated.d.ts

@@ -0,0 +1,61 @@
+declare const _default: {
+    katas: {
+        id: string;
+        title: string;
+        sections: ({
+            type: string;
+            id: string;
+            title: string;
+            items: ({
+                type: string;
+                asHtml: string;
+                asMarkdown: string;
+                id?: undefined;
+                code?: undefined;
+            } | {
+                type: string;
+                id: string;
+                code: string;
+                asHtml?: undefined;
+                asMarkdown?: undefined;
+            })[];
+            description?: undefined;
+            sourceIds?: undefined;
+            placeholderCode?: undefined;
+            explainedSolution?: undefined;
+        } | {
+            type: string;
+            id: string;
+            title: string;
+            description: {
+                type: string;
+                asHtml: string;
+                asMarkdown: string;
+            };
+            sourceIds: string[];
+            placeholderCode: string;
+            explainedSolution: {
+                type: string;
+                items: ({
+                    type: string;
+                    asHtml: string;
+                    asMarkdown: string;
+                    id?: undefined;
+                    code?: undefined;
+                } | {
+                    type: string;
+                    id: string;
+                    code: string;
+                    asHtml?: undefined;
+                    asMarkdown?: undefined;
+                })[];
+            };
+            items?: undefined;
+        })[];
+    }[];
+    globalCodeSources: {
+        id: string;
+        code: string;
+    }[];
+};
+export default _default;