qsharp-lang 1.1.5-dev → 1.2.0

package/dist/compiler/compiler.d.ts

@@ -4,22 +4,40 @@ 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;

package/dist/compiler/compiler.js

@@ -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));

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

@@ -4,7 +4,7 @@ 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>;

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

@@ -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;