qsharp-lang 1.0.28-dev → 1.0.29-dev

package/dist/browser.d.ts

@@ -1,3 +1,4 @@
+import * as wasm from "../lib/web/qsc_wasm.js";
 import { TargetProfile } from "../lib/web/qsc_wasm.js";
 import { ICompiler, ICompilerWorker } from "./compiler/compiler.js";
 import { IDebugService, IDebugServiceWorker } from "./debug-service/debug-service.js";
@@ -7,10 +8,15 @@ export { qsharpLibraryUriScheme };
 export declare function loadWasmModule(uriOrBuffer: string | ArrayBuffer): Promise<void>;
 export declare function getLibrarySourceContent(path: string): Promise<string | undefined>;
 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 getCompiler(): Promise<ICompiler>;
 export declare function getCompilerWorker(workerArg: string | Worker): ICompilerWorker;
-export declare function getLanguageService(): Promise<ILanguageService>;
+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 { type Dump, type ShotResult } from "./compiler/common.js";
 export { type CompilerState } from "./compiler/compiler.js";

package/dist/browser.js

@@ -72,6 +72,10 @@ export async function getDebugService() {
     await instantiateWasm();
     return new QSharpDebugService(wasm);
 }
+export async function getProjectLoader(readFile, loadDirectory, getManifest) {
+    await instantiateWasm();
+    return new wasm.ProjectLoader(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.
@@ -122,9 +126,9 @@ export function getCompilerWorker(workerArg) {
     worker.onmessage = (ev) => proxy.onMsgFromWorker(ev.data);
     return proxy;
 }
-export async function getLanguageService() {
+export async function getLanguageService(readFile, listDir, getManifest) {
     await instantiateWasm();
-    return new QSharpLanguageService(wasm);
+    return new QSharpLanguageService(wasm, 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

package/dist/compiler/compiler.d.ts

@@ -5,9 +5,9 @@ type Wasm = typeof import("../../lib/node/qsc_wasm.cjs");
 export interface ICompiler {
     checkCode(code: string): Promise<VSDiagnostic[]>;
     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>;
+    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>;
     checkExerciseSolution(user_code: string, exercise_sources: string[], eventHandler: IQscEventTarget): Promise<boolean>;
 }
 export type ICompilerWorker = ICompiler & IServiceProxy;
@@ -16,10 +16,10 @@ export declare class Compiler implements ICompiler {
     private wasm;
     constructor(wasm: Wasm);
     checkCode(code: string): Promise<VSDiagnostic[]>;
-    getQir(code: string): Promise<string>;
-    getEstimates(code: string, params: string): Promise<string>;
+    getQir(sources: [string, string][]): Promise<string>;
+    getEstimates(sources: [string, string][], params: string): Promise<string>;
     getHir(code: string): Promise<string>;
-    run(code: string, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
+    run(sources: [string, string][], expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
     checkExerciseSolution(user_code: string, exercise_sources: string[], eventHandler: IQscEventTarget): Promise<boolean>;
 }
 export declare function onCompilerEvent(msg: string, eventTarget: IQscEventTarget): void;

package/dist/compiler/compiler.js

@@ -10,28 +10,36 @@ export class Compiler {
         this.wasm = wasm;
         globalThis.qscGitHash = this.wasm.git_hash();
     }
+    // Note: This function does not support project mode.
+    // see https://github.com/microsoft/qsharp/pull/849#discussion_r1409821143
     async checkCode(code) {
         let diags = [];
-        const languageService = new this.wasm.LanguageService((uri, version, errors) => {
+        const languageService = new this.wasm.LanguageService();
+        const work = languageService.start_background_work((uri, version, errors) => {
             diags = errors;
-        });
+        }, () => Promise.resolve(null), () => Promise.resolve([]), () => Promise.resolve(null));
         languageService.update_document("code", 1, code);
+        // Yield to let the language service background worker handle the update
+        await Promise.resolve();
+        languageService.stop_background_work();
+        await work;
+        languageService.free();
         return mapDiagnostics(diags, code);
     }
-    async getQir(code) {
-        return this.wasm.get_qir(code);
+    async getQir(sources) {
+        return this.wasm.get_qir(sources);
     }
-    async getEstimates(code, params) {
-        return this.wasm.get_estimates(code, params);
+    async getEstimates(sources, params) {
+        return this.wasm.get_estimates(sources, params);
     }
     async getHir(code) {
         return this.wasm.get_hir(code);
     }
-    async run(code, expr, shots, eventHandler) {
+    async run(sources, expr, shots, eventHandler) {
         // 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(code, expr, (msg) => onCompilerEvent(msg, eventHandler), shots);
+        this.wasm.run(sources, expr, (msg) => onCompilerEvent(msg, eventHandler), shots);
     }
     async checkExerciseSolution(user_code, exercise_sources, eventHandler) {
         const success = this.wasm.check_exercise_solution(user_code, exercise_sources, (msg) => onCompilerEvent(msg, eventHandler));

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

@@ -4,7 +4,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, target: TargetProfile, entry: string | undefined): Promise<string>;
+    loadSource(sources: [string, string][], target: TargetProfile, entry: string | undefined): Promise<string>;
     getBreakpoints(path: string): Promise<IBreakpointSpan[]>;
     getLocalVariables(): Promise<Array<IVariable>>;
     captureQuantumState(): Promise<Array<IQuantumState>>;
@@ -21,7 +21,7 @@ export declare class QSharpDebugService implements IDebugService {
     private debugService;
     private code;
     constructor(wasm: QscWasm);
-    loadSource(path: string, source: string, target: TargetProfile, entry: string | undefined): Promise<string>;
+    loadSource(sources: [string, string][], target: TargetProfile, 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,11 @@ export class QSharpDebugService {
         this.wasm = wasm;
         this.debugService = new wasm.DebugService();
     }
-    async loadSource(path, source, target, entry) {
-        this.code[path] = source;
-        return this.debugService.load_source(path, source, target, entry);
+    async loadSource(sources, target, entry) {
+        for (const [path, source] of sources) {
+            this.code[path] = source;
+        }
+        return this.debugService.load_source(sources, target, entry);
     }
     async getStackFrames() {
         const stack_frame_list = this.debugService.get_stack_frames();

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

@@ -41,7 +41,12 @@ export declare class QSharpLanguageService implements ILanguageService {
     private languageService;
     private eventHandler;
     private code;
-    constructor(wasm: QscWasm);
+    private readFile;
+    private backgroundWork;
+    constructor(wasm: QscWasm, readFile?: (uri: string) => Promise<string | null>, listDir?: (uri: string) => Promise<[string, number][]>, getManifest?: (uri: string) => Promise<{
+        manifestDirectory: string;
+    } | null>);
+    loadFile(uri: string): Promise<string | null>;
     updateConfiguration(config: IWorkspaceConfiguration): Promise<void>;
     updateDocument(documentUri: string, version: number, code: string): Promise<void>;
     updateNotebookDocument(notebookUri: string, version: number, metadata: INotebookMetadata, cells: {
@@ -65,6 +70,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 | undefined, diagnostics: VSDiagnostic[]): void;
+    onDiagnostics(uri: string, version: number | undefined, diagnostics: VSDiagnostic[]): Promise<void>;
 }
 export {};

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

@@ -5,12 +5,25 @@ import { log } from "../log.js";
 import { mapDiagnostics, mapUtf16UnitsToUtf8Units, mapUtf8UnitsToUtf16Units, } from "../vsdiagnostic.js";
 export const qsharpLibraryUriScheme = "qsharp-library-source";
 export class QSharpLanguageService {
-    constructor(wasm) {
+    constructor(wasm, readFile = () => Promise.resolve(null), listDir = () => Promise.resolve([]), getManifest = () => Promise.resolve(null)) {
         this.eventHandler = new EventTarget();
         // We need to keep a copy of the code for mapping diagnostics to utf16 offsets
         this.code = {};
         log.info("Constructing a QSharpLanguageService instance");
-        this.languageService = new wasm.LanguageService(this.onDiagnostics.bind(this));
+        this.languageService = new wasm.LanguageService();
+        this.backgroundWork = this.languageService.start_background_work(this.onDiagnostics.bind(this), readFile, listDir, getManifest);
+        this.readFile = readFile;
+    }
+    async loadFile(uri) {
+        const result = this.code[uri];
+        if (result === undefined || result === null) {
+            return await this.readFile(uri);
+        }
+        if (result === null || result === undefined) {
+            log.error("File", uri, "wasn't in document map when we expected it to be");
+            return null;
+        }
+        return result;
     }
     async updateConfiguration(config) {
         this.languageService.update_configuration(config);
@@ -37,8 +50,8 @@ export class QSharpLanguageService {
         this.languageService.close_notebook_document(documentUri, cellUris);
     }
     async getCompletions(documentUri, offset) {
-        const code = this.code[documentUri];
-        if (code === undefined) {
+        const code = await this.loadFile(documentUri);
+        if (code === null) {
             log.error(`getCompletions: expected ${documentUri} to be in the document map`);
             return { items: [] };
         }
@@ -50,8 +63,8 @@ export class QSharpLanguageService {
         return result;
     }
     async getHover(documentUri, offset) {
-        const code = this.code[documentUri];
-        if (code === undefined) {
+        const code = await this.loadFile(documentUri);
+        if (code === null) {
             log.error(`getHover: expected ${documentUri} to be in the document map`);
             return undefined;
         }
@@ -63,22 +76,22 @@ export class QSharpLanguageService {
         return result;
     }
     async getDefinition(documentUri, offset) {
-        const sourceCode = this.code[documentUri];
-        if (sourceCode === undefined) {
+        const sourceCode = await this.loadFile(documentUri);
+        if (sourceCode === undefined || sourceCode === null) {
             log.error(`getDefinition: expected ${documentUri} to be in the document map`);
             return undefined;
         }
         const convertedOffset = mapUtf16UnitsToUtf8Units([offset], sourceCode)[offset];
         const result = this.languageService.get_definition(documentUri, convertedOffset);
         if (result) {
-            let targetCode = this.code[result.source];
-            if (targetCode === undefined) {
+            let targetCode = (await this.loadFile(result.source)) || null;
+            if (targetCode === null) {
                 // 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);
+                    targetCode = wasm.get_library_source_content(url.pathname) || null;
                     if (targetCode === undefined) {
                         log.error(`getDefinition: expected ${url} to be in the library`);
                         return undefined;
@@ -96,8 +109,8 @@ export class QSharpLanguageService {
         return result;
     }
     async getReferences(documentUri, offset, includeDeclaration) {
-        const sourceCode = this.code[documentUri];
-        if (sourceCode === undefined) {
+        const sourceCode = await this.loadFile(documentUri);
+        if (sourceCode === undefined || sourceCode === null) {
             log.error(`getReferences: expected ${documentUri} to be in the document map`);
             return [];
         }
@@ -106,13 +119,13 @@ export class QSharpLanguageService {
         if (results && results.length > 0) {
             const references = [];
             for (const result of results) {
-                let resultCode = this.code[result.source];
+                let resultCode = await this.loadFile(result.source);
                 // 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 + ":") {
-                    resultCode = wasm.get_library_source_content(url.pathname);
+                    resultCode = wasm.get_library_source_content(url.pathname) || null;
                     if (resultCode === undefined) {
                         log.error(`getReferences: expected ${url} to be in the library`);
                     }
@@ -133,8 +146,8 @@ export class QSharpLanguageService {
         }
     }
     async getSignatureHelp(documentUri, offset) {
-        const code = this.code[documentUri];
-        if (code === undefined) {
+        const code = await this.loadFile(documentUri);
+        if (code === null) {
             log.error(`expected ${documentUri} to be in the document map`);
             return undefined;
         }
@@ -152,8 +165,8 @@ export class QSharpLanguageService {
         return result;
     }
     async getRename(documentUri, offset, newName) {
-        const code = this.code[documentUri];
-        if (code === undefined) {
+        const code = await this.loadFile(documentUri);
+        if (code === null) {
             log.error(`expected ${documentUri} to be in the document map`);
             return undefined;
         }
@@ -161,7 +174,7 @@ export class QSharpLanguageService {
         const result = this.languageService.get_rename(documentUri, convertedOffset, newName);
         const mappedChanges = [];
         for (const [uri, edits] of result.changes) {
-            const code = this.code[uri];
+            const code = await this.loadFile(uri);
             if (code) {
                 const mappedEdits = edits.map((edit) => {
                     updateSpanFromUtf8ToUtf16(edit.range, code);
@@ -174,8 +187,8 @@ export class QSharpLanguageService {
         return result;
     }
     async prepareRename(documentUri, offset) {
-        const code = this.code[documentUri];
-        if (code === undefined) {
+        const code = await this.loadFile(documentUri);
+        if (code === null) {
             log.error(`expected ${documentUri} to be in the document map`);
             return undefined;
         }
@@ -187,6 +200,8 @@ export class QSharpLanguageService {
         return result;
     }
     async dispose() {
+        this.languageService.stop_background_work();
+        await this.backgroundWork;
         this.languageService.free();
     }
     addEventListener(type, listener) {
@@ -195,18 +210,21 @@ export class QSharpLanguageService {
     removeEventListener(type, listener) {
         this.eventHandler.removeEventListener(type, listener);
     }
-    onDiagnostics(uri, version, diagnostics) {
+    async onDiagnostics(uri, version, diagnostics) {
         try {
-            const code = this.code[uri];
+            const code = await this.loadFile(uri);
             const empty = diagnostics.length === 0;
-            if (code === undefined && !empty) {
+            if (code === null && !empty) {
                 // We need the contents of the document to convert error offsets to utf16.
                 // But the contents aren't available after a document is closed.
-                // It is possible to get a diagnostics event after a document is closed,
-                // but it will be done with an empty array, to clear the diagnostics.
-                // In that case, it's ok not to have the document contents available,
-                // because there are no offsets to convert.
-                log.error(`onDiagnostics: expected ${uri} to be in the document map`);
+                // It is possible to get diagnostics events for a document after it's been closed,
+                // since document events are handled asynchronously by the language service.
+                // We just drop those diagnostics, assuming that eventually we will receive further
+                // events that will bring the diagnostics up to date.
+                // However, if we receive an *empty* array of diagnostics for a document, we don't want
+                // to drop that update. It's necessary for the diagnostics to get cleared for a document
+                // that has been closed.
+                log.warn(`onDiagnostics: received diagnostics for ${uri} which is not in the document map`);
                 return;
             }
             const event = new Event("diagnostics");

package/dist/main.d.ts

@@ -1,11 +1,17 @@
 import { ICompiler, ICompilerWorker } from "./compiler/compiler.js";
 import { ILanguageService, ILanguageServiceWorker, qsharpLibraryUriScheme } from "./language-service/language-service.js";
 import { IDebugService, IDebugServiceWorker } from "./debug-service/debug-service.js";
+import { ProjectLoader } from "../lib/node/qsc_wasm.cjs";
 export { qsharpLibraryUriScheme };
 export declare function getLibrarySourceContent(path: string): Promise<string | undefined>;
 export declare function getCompiler(): ICompiler;
+export declare function getProjectLoader(readFile: (path: string) => Promise<string | null>, loadDirectory: (path: string) => Promise<[string, number][]>, getManifest: (path: string) => Promise<{
+    manifestDirectory: string;
+} | null>): ProjectLoader;
 export declare function getCompilerWorker(): ICompilerWorker;
 export declare function getDebugService(): IDebugService;
 export declare function getDebugServiceWorker(): IDebugServiceWorker;
-export declare function getLanguageService(): ILanguageService;
+export declare function getLanguageService(readFile?: (uri: string) => Promise<string | null>, listDir?: (uri: string) => Promise<[string, number][]>, getManifest?: (uri: string) => Promise<{
+    manifestDirectory: string;
+} | null>): ILanguageService;
 export declare function getLanguageServiceWorker(): ILanguageServiceWorker;

package/dist/main.js

@@ -31,6 +31,15 @@ export function getCompiler() {
     }
     return new Compiler(wasm);
 }
+export function getProjectLoader(readFile, loadDirectory, getManifest) {
+    if (!wasm) {
+        wasm = require("../lib/node/qsc_wasm.cjs");
+        // Set up logging and telemetry as soon as possible after instantiating
+        wasm.initLogging(log.logWithLevel, log.getLogLevel());
+        log.onLevelChanged = (level) => wasm?.setLogLevel(level);
+    }
+    return new wasm.ProjectLoader(readFile, loadDirectory, getManifest);
+}
 export function getCompilerWorker() {
     const thisDir = dirname(fileURLToPath(import.meta.url));
     const worker = new Worker(join(thisDir, "./compiler/worker-node.js"), {
@@ -62,10 +71,10 @@ export function getDebugServiceWorker() {
     worker.addListener("message", proxy.onMsgFromWorker);
     return proxy;
 }
-export function getLanguageService() {
+export function getLanguageService(readFile, listDir, getManifest) {
     if (!wasm)
         wasm = require("../lib/node/qsc_wasm.cjs");
-    return new QSharpLanguageService(wasm);
+    return new QSharpLanguageService(wasm, readFile, listDir, getManifest);
 }
 export function getLanguageServiceWorker() {
     const thisDir = dirname(fileURLToPath(import.meta.url));