qsharp-lang 1.6.1-dev → 1.6.3-dev

package/dist/browser.d.ts

@@ -1,29 +1,25 @@
 import * as wasm from "../lib/web/qsc_wasm.js";
-import { TargetProfile } from "../lib/web/qsc_wasm.js";
+import { IProjectHost, TargetProfile } from "../lib/web/qsc_wasm.js";
 import { ICompiler, ICompilerWorker } from "./compiler/compiler.js";
 import { IDebugService, IDebugServiceWorker } from "./debug-service/debug-service.js";
-import { ILanguageService, ILanguageServiceWorker, qsharpLibraryUriScheme } from "./language-service/language-service.js";
+import { ILanguageService, ILanguageServiceWorker, qsharpGithubUriScheme, qsharpLibraryUriScheme } from "./language-service/language-service.js";
 import { LogLevel, log } from "./log.js";
-export { qsharpLibraryUriScheme };
+export { qsharpGithubUriScheme, 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 getProjectLoader(host: IProjectHost): Promise<wasm.ProjectLoader>;
 export declare function getDebugServiceWorker(worker: string | Worker): IDebugServiceWorker;
 export declare function getCompiler(): Promise<ICompiler>;
 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 getLanguageService(host?: IProjectHost): Promise<ILanguageService>;
 export declare function getLanguageServiceWorker(worker: string | Worker): ILanguageServiceWorker;
 export { StepResultId } from "../lib/web/qsc_wasm.js";
-export type { IBreakpointSpan, ICodeAction, ICodeLens, IDocFile, ILocation, IOperationInfo, IPosition, IQSharpError, IRange, IStackFrame, IWorkspaceEdit, IStructStepResult, VSDiagnostic, } from "../lib/web/qsc_wasm.js";
+export type { IBreakpointSpan, ICodeAction, ICodeLens, IDocFile, ILocation, IOperationInfo, IPosition, IProjectConfig, IProjectHost, IQSharpError, IRange, IStackFrame, IStructStepResult, IWorkspaceEdit, ProjectLoader, VSDiagnostic, } from "../lib/web/qsc_wasm.js";
 export { type Dump, type ShotResult } from "./compiler/common.js";
 export { type CompilerState, type ProgramConfig } from "./compiler/compiler.js";
 export { QscEventTarget } from "./compiler/events.js";
-export { type LanguageServiceEvent } from "./language-service/language-service.js";
+export type { LanguageServiceEvent } from "./language-service/language-service.js";
 export { default as samples } from "./samples.generated.js";
 export { log, type LogLevel, type TargetProfile };
 export type { ICompiler, ICompilerWorker, IDebugService, IDebugServiceWorker, ILanguageService, ILanguageServiceWorker, };

package/dist/browser.js

@@ -6,10 +6,10 @@ 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 { QSharpLanguageService, languageServiceProtocol, qsharpGithubUriScheme, qsharpLibraryUriScheme, } from "./language-service/language-service.js";
 import { log } from "./log.js";
 import { createProxy } from "./workers/browser.js";
-export { qsharpLibraryUriScheme };
+export { qsharpGithubUriScheme, qsharpLibraryUriScheme };
 // Create once. A module is stateless and can be efficiently passed to WebWorkers.
 let wasmModule = null;
 let wasmModulePromise = null;
@@ -71,9 +71,9 @@ export async function getDebugService() {
     await instantiateWasm();
     return new QSharpDebugService(wasm);
 }
-export async function getProjectLoader(readFile, loadDirectory, getManifest) {
+export async function getProjectLoader(host) {
     await instantiateWasm();
-    return new wasm.ProjectLoader(readFile, loadDirectory, getManifest);
+    return new wasm.ProjectLoader(host);
 }
 // Create the debugger inside a WebWorker and proxy requests.
 // If the Worker was already created via other means and is ready to receive
@@ -95,9 +95,9 @@ export function getCompilerWorker(worker) {
         throw "Wasm module must be loaded first";
     return createProxy(worker, wasmModule, compilerProtocol);
 }
-export async function getLanguageService(readFile, listDir, getManifest) {
+export async function getLanguageService(host) {
     await instantiateWasm();
-    return new QSharpLanguageService(wasm, readFile, listDir, getManifest);
+    return new QSharpLanguageService(wasm, host);
 }
 // 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

@@ -1,5 +1,5 @@
 import { type Circuit as CircuitData } from "@microsoft/quantum-viz.js/lib/circuit.js";
-import { IDocFile, IOperationInfo, TargetProfile, type VSDiagnostic } from "../../lib/web/qsc_wasm.js";
+import { IDocFile, IOperationInfo, IPackageGraphSources, IProgramConfig as wasmIProgramConfig, TargetProfile, type VSDiagnostic } from "../../lib/web/qsc_wasm.js";
 import { IServiceProxy, ServiceProtocol, ServiceState } from "../workers/common.js";
 import { IQscEventTarget, QscEventData } from "./events.js";
 type Wasm = typeof import("../../lib/web/qsc_wasm.js");
@@ -7,40 +7,26 @@ export interface ICompiler {
     checkCode(code: string): Promise<VSDiagnostic[]>;
     getAst(code: string, languageFeatures?: string[], profile?: TargetProfile): Promise<string>;
     getHir(code: string, languageFeatures?: string[], profile?: TargetProfile): 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.
-     **/
-    run(sources: [string, string][], expr: string, shots: number, 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>;
-    getEstimates(config: ProgramConfig, params: string): Promise<string>;
-    getCircuit(config: ProgramConfig, target: TargetProfile, simulate: boolean, operation?: IOperationInfo): Promise<CircuitData>;
-    getDocumentation(additionalSources?: [string, string][], targetProfile?: string, languageFeatures?: string[]): Promise<IDocFile[]>;
+    run(program: ProgramConfig, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
+    getQir(program: ProgramConfig): Promise<string>;
+    getEstimates(program: ProgramConfig, params: string): Promise<string>;
+    getCircuit(program: ProgramConfig, simulate: boolean, operation?: IOperationInfo): Promise<CircuitData>;
+    getDocumentation(additionalProgram?: ProgramConfig): Promise<IDocFile[]>;
     checkExerciseSolution(userCode: string, exerciseSources: string[], eventHandler: IQscEventTarget): Promise<boolean>;
 }
-/** Type definition for the configuration of a program. */
-export type ProgramConfig = {
+/**
+ * Type definition for the configuration of a program.
+ * If adding new properties, make them optional to maintain backward compatibility.
+ */
+export type ProgramConfig = ({
     /** An array of source objects, each containing a name and contents. */
     sources: [string, string][];
     /** An array of language features to be opted in to in this compilation. */
     languageFeatures?: string[];
+} | {
+    /** Sources from all resolved dependencies, along with their languageFeatures configuration */
+    packageGraphSources: IPackageGraphSources;
+}) & {
     /** Target compilation profile. */
     profile?: TargetProfile;
 };
@@ -50,19 +36,20 @@ export declare class Compiler implements ICompiler {
     private wasm;
     constructor(wasm: Wasm);
     checkCode(code: string): Promise<VSDiagnostic[]>;
-    getQir(sourcesOrConfig: [string, string][] | ProgramConfig, languageFeatures?: string[]): Promise<string>;
-    newGetQir({ sources, languageFeatures, profile, }: 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, profile }: ProgramConfig, params: string): Promise<string>;
-    deprecatedGetEstimates(sources: [string, string][], params: string, languageFeatures: string[]): Promise<string>;
     getAst(code: string, languageFeatures?: string[], profile?: TargetProfile): Promise<string>;
     getHir(code: string, languageFeatures: string[], profile: TargetProfile): Promise<string>;
-    run(sourcesOrConfig: [string, string][] | ProgramConfig, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
-    getCircuit(config: ProgramConfig, target: TargetProfile, simulate: boolean, operation?: IOperationInfo): Promise<CircuitData>;
-    getDocumentation(additionalSources?: [string, string][], targetProfile?: string, languageFeatures?: string[]): Promise<IDocFile[]>;
+    run(program: ProgramConfig, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
+    getQir(program: ProgramConfig): Promise<string>;
+    getEstimates(program: ProgramConfig, params: string): Promise<string>;
+    getCircuit(program: ProgramConfig, simulate: boolean, operation?: IOperationInfo): Promise<CircuitData>;
+    getDocumentation(additionalProgram?: ProgramConfig): Promise<IDocFile[]>;
     checkExerciseSolution(userCode: string, exerciseSources: string[], eventHandler: IQscEventTarget): Promise<boolean>;
 }
+/**
+ * Fills in the defaults, to convert from the backwards-compatible ProgramConfig,
+ * to the IProgramConfig type that the wasm layer expects
+ */
+export declare function toWasmProgramConfig(program: ProgramConfig, defaultProfile: TargetProfile): Required<wasmIProgramConfig>;
 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>;

package/dist/compiler/compiler.js

@@ -16,7 +16,13 @@ export class Compiler {
         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));
+        }, {
+            readFile: async () => null,
+            listDirectory: async () => [],
+            resolvePath: async () => null,
+            fetchGithub: async () => "",
+            findManifestDirectory: async () => null,
+        });
         languageService.update_document("code", 1, code);
         // Yield to let the language service background worker handle the update
         await Promise.resolve();
@@ -25,75 +31,63 @@ export class Compiler {
         languageService.free();
         return diags;
     }
-    async getQir(sourcesOrConfig, languageFeatures) {
-        if (Array.isArray(sourcesOrConfig)) {
-            return this.deprecatedGetQir(sourcesOrConfig, languageFeatures || []);
-        }
-        else {
-            const config = sourcesOrConfig;
-            return this.newGetQir(config);
-        }
-    }
-    async newGetQir({ sources, languageFeatures = [], profile = "base", }) {
-        return this.wasm.get_qir(sources, languageFeatures, profile);
-    }
-    async deprecatedGetQir(sources, languageFeatures) {
-        return this.wasm.get_qir(sources, languageFeatures, "base");
-    }
-    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, profile = "unrestricted" }, params) {
-        return this.wasm.get_estimates(sources, params, languageFeatures || [], profile);
-    }
-    async deprecatedGetEstimates(sources, params, languageFeatures) {
-        return this.wasm.get_estimates(sources, params, languageFeatures, "unrestricted");
-    }
     async getAst(code, languageFeatures, profile) {
         return this.wasm.get_ast(code, languageFeatures ?? [], profile ?? "adaptive_ri");
     }
     async getHir(code, languageFeatures, profile) {
         return this.wasm.get_hir(code, languageFeatures ?? [], profile ?? "adaptive_ri");
     }
-    async run(sourcesOrConfig, expr, shots, eventHandler) {
-        let sources;
-        let profile = "unrestricted";
-        let languageFeatures = [];
-        if (Array.isArray(sourcesOrConfig)) {
-            // this is the deprecated API
-            sources = sourcesOrConfig;
-        }
-        else {
-            // this is the new API
-            sources = sourcesOrConfig.sources;
-            languageFeatures = sourcesOrConfig.languageFeatures || [];
-            profile = sourcesOrConfig.profile || "unrestricted";
-        }
+    async run(program, 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(sources, expr, (msg) => onCompilerEvent(msg, eventHandler), shots, languageFeatures, profile);
+        this.wasm.run(toWasmProgramConfig(program, "unrestricted"), expr, (msg) => onCompilerEvent(msg, eventHandler), shots);
+    }
+    async getQir(program) {
+        return this.wasm.get_qir(toWasmProgramConfig(program, "base"));
     }
-    async getCircuit(config, target, simulate, operation) {
-        return this.wasm.get_circuit(config.sources, target, config.languageFeatures || [], simulate, operation);
+    async getEstimates(program, params) {
+        return this.wasm.get_estimates(toWasmProgramConfig(program, "unrestricted"), params);
+    }
+    async getCircuit(program, simulate, operation) {
+        return this.wasm.get_circuit(toWasmProgramConfig(program, "unrestricted"), simulate, operation);
     }
     // Returns all autogenerated documentation files for the standard library
     // and loaded project (if requested). This include file names and metadata,
     // including specially formatted table of content file.
-    async getDocumentation(additionalSources, targetProfile, languageFeatures) {
-        // Get documentation from wasm layer
-        return this.wasm.generate_docs(additionalSources, targetProfile, languageFeatures);
+    async getDocumentation(additionalProgram) {
+        return this.wasm.generate_docs(additionalProgram &&
+            toWasmProgramConfig(additionalProgram, "unrestricted"));
     }
     async checkExerciseSolution(userCode, exerciseSources, eventHandler) {
         const success = this.wasm.check_exercise_solution(userCode, exerciseSources, (msg) => onCompilerEvent(msg, eventHandler));
         return success;
     }
 }
+/**
+ * Fills in the defaults, to convert from the backwards-compatible ProgramConfig,
+ * to the IProgramConfig type that the wasm layer expects
+ */
+export function toWasmProgramConfig(program, defaultProfile) {
+    let packageGraphSources;
+    if ("sources" in program) {
+        // The simpler type is used, where there are no dependencies and only a list
+        // of sources is passed in.
+        packageGraphSources = {
+            root: {
+                sources: program.sources,
+                languageFeatures: program.languageFeatures || [],
+                dependencies: {},
+            },
+            packages: {},
+        };
+    }
+    else {
+        // A full package graph is passed in.
+        packageGraphSources = program.packageGraphSources;
+    }
+    return { packageGraphSources, profile: program.profile || defaultProfile };
+}
 export function onCompilerEvent(msg, eventTarget) {
     const qscMsg = eventStringToMsg(msg);
     if (!qscMsg) {

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

@@ -1,11 +1,11 @@
 import { type Circuit as CircuitData } from "@microsoft/quantum-viz.js/lib/circuit.js";
 import type { IBreakpointSpan, IQuantumState, IStackFrame, IStructStepResult, IVariable } from "../../lib/web/qsc_wasm.js";
-import { TargetProfile } from "../browser.js";
+import { ProgramConfig } from "../browser.js";
 import { IQscEventTarget, QscEventData } from "../compiler/events.js";
 import { IServiceProxy, ServiceProtocol } from "../workers/common.js";
 type QscWasm = typeof import("../../lib/web/qsc_wasm.js");
 export interface IDebugService {
-    loadSource(sources: [string, string][], target: TargetProfile, entry: string | undefined, language_features: string[]): Promise<string>;
+    loadProgram(program: ProgramConfig, entry: string | undefined): Promise<string>;
     getBreakpoints(path: string): Promise<IBreakpointSpan[]>;
     getLocalVariables(): Promise<Array<IVariable>>;
     captureQuantumState(): Promise<Array<IQuantumState>>;
@@ -22,7 +22,7 @@ export declare class QSharpDebugService implements IDebugService {
     private wasm;
     private debugService;
     constructor(wasm: QscWasm);
-    loadSource(sources: [string, string][], target: TargetProfile, entry: string | undefined, language_features: string[]): Promise<string>;
+    loadProgram(program: ProgramConfig, entry: string | undefined): Promise<string>;
     getBreakpoints(path: string): Promise<IBreakpointSpan[]>;
     getLocalVariables(): Promise<Array<IVariable>>;
     captureQuantumState(): Promise<Array<IQuantumState>>;

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

@@ -3,14 +3,15 @@
 import { eventStringToMsg } from "../compiler/common.js";
 import { makeEvent, } from "../compiler/events.js";
 import { log } from "../log.js";
+import { toWasmProgramConfig } from "../compiler/compiler.js";
 export class QSharpDebugService {
     constructor(wasm) {
         log.info("Constructing a QSharpDebugService instance");
         this.wasm = wasm;
         this.debugService = new wasm.DebugService();
     }
-    async loadSource(sources, target, entry, language_features) {
-        return this.debugService.load_source(sources, target, entry, language_features);
+    async loadProgram(program, entry) {
+        return this.debugService.load_program(toWasmProgramConfig(program, "unrestricted"), entry);
     }
     async getBreakpoints(path) {
         return this.debugService.get_breakpoints(path).spans;
@@ -85,7 +86,7 @@ export function onCompilerEvent(msg, eventTarget) {
 export const debugServiceProtocol = {
     class: QSharpDebugService,
     methods: {
-        loadSource: "request",
+        loadProgram: "request",
         getBreakpoints: "request",
         getLocalVariables: "request",
         captureQuantumState: "request",