qsharp-lang 1.0.34-dev → 1.1.0-dev

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

@@ -1,202 +1,50 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import * as wasm from "../../lib/web/qsc_wasm.js";
 import { log } from "../log.js";
-import { mapDiagnostics, mapUtf16UnitsToUtf8Units, mapUtf8UnitsToUtf16Units, } from "../vsdiagnostic.js";
 export const qsharpLibraryUriScheme = "qsharp-library-source";
 export class QSharpLanguageService {
     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.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);
     }
     async updateDocument(documentUri, version, code) {
-        this.code[documentUri] = code;
         this.languageService.update_document(documentUri, version, code);
     }
     async updateNotebookDocument(notebookUri, version, metadata, cells) {
-        // Note: If a cell was deleted, its uri & contents will remain in the map.
-        // This is harmless and it keeps the code simpler to just leave it this way
-        // instead of trying to maintain a perfect map.
-        for (const cell of cells) {
-            this.code[cell.uri] = cell.code;
-        }
         this.languageService.update_notebook_document(notebookUri, metadata, cells);
     }
     async closeDocument(documentUri) {
-        delete this.code[documentUri];
         this.languageService.close_document(documentUri);
     }
     async closeNotebookDocument(documentUri) {
         this.languageService.close_notebook_document(documentUri);
     }
-    async getCompletions(documentUri, offset) {
-        const code = await this.loadFile(documentUri);
-        if (code === null) {
-            log.error(`getCompletions: expected ${documentUri} to be in the document map`);
-            return { items: [] };
-        }
-        const convertedOffset = mapUtf16UnitsToUtf8Units([offset], code)[offset];
-        const result = this.languageService.get_completions(documentUri, convertedOffset);
-        result.items.forEach((item) => item.additionalTextEdits?.forEach((edit) => {
-            updateSpanFromUtf8ToUtf16(edit.range, code);
-        }));
-        return result;
-    }
-    async getHover(documentUri, offset) {
-        const code = await this.loadFile(documentUri);
-        if (code === null) {
-            log.error(`getHover: expected ${documentUri} to be in the document map`);
-            return undefined;
-        }
-        const convertedOffset = mapUtf16UnitsToUtf8Units([offset], code)[offset];
-        const result = this.languageService.get_hover(documentUri, convertedOffset);
-        if (result) {
-            updateSpanFromUtf8ToUtf16(result.span, code);
-        }
-        return result;
+    async getCompletions(documentUri, position) {
+        return this.languageService.get_completions(documentUri, position);
     }
-    async getDefinition(documentUri, offset) {
-        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 = (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) || null;
-                    if (targetCode === undefined) {
-                        log.error(`getDefinition: expected ${url} to be in the library`);
-                        return undefined;
-                    }
-                }
-            }
-            if (targetCode) {
-                updateSpanFromUtf8ToUtf16(result.span, targetCode);
-            }
-            else {
-                // https://github.com/microsoft/qsharp/issues/851
-                log.error(`cannot do utf8->utf16 mapping for ${result.source} since contents are not available`);
-            }
-        }
-        return result;
+    async getHover(documentUri, position) {
+        return this.languageService.get_hover(documentUri, position);
     }
-    async getReferences(documentUri, offset, includeDeclaration) {
-        const sourceCode = await this.loadFile(documentUri);
-        if (sourceCode === undefined || sourceCode === null) {
-            log.error(`getReferences: expected ${documentUri} to be in the document map`);
-            return [];
-        }
-        const convertedOffset = mapUtf16UnitsToUtf8Units([offset], sourceCode)[offset];
-        const results = this.languageService.get_references(documentUri, convertedOffset, includeDeclaration);
-        if (results && results.length > 0) {
-            const references = [];
-            for (const result of results) {
-                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) || null;
-                    if (resultCode === undefined) {
-                        log.error(`getReferences: expected ${url} to be in the library`);
-                    }
-                }
-                if (resultCode) {
-                    updateSpanFromUtf8ToUtf16(result.span, resultCode);
-                    references.push(result);
-                }
-                else {
-                    // https://github.com/microsoft/qsharp/issues/851
-                    log.error(`cannot do utf8->utf16 mapping for ${result.source} since contents are not available`);
-                }
-            }
-            return references;
-        }
-        else {
-            return [];
-        }
+    async getDefinition(documentUri, position) {
+        return this.languageService.get_definition(documentUri, position);
     }
-    async getSignatureHelp(documentUri, offset) {
-        const code = await this.loadFile(documentUri);
-        if (code === null) {
-            log.error(`expected ${documentUri} to be in the document map`);
-            return undefined;
-        }
-        const convertedOffset = mapUtf16UnitsToUtf8Units([offset], code)[offset];
-        const result = this.languageService.get_signature_help(documentUri, convertedOffset);
-        if (result) {
-            result.signatures = result.signatures.map((sig) => {
-                sig.parameters = sig.parameters.map((param) => {
-                    updateSpanFromUtf8ToUtf16(param.label, sig.label);
-                    return param;
-                });
-                return sig;
-            });
-        }
-        return result;
+    async getReferences(documentUri, position, includeDeclaration) {
+        return this.languageService.get_references(documentUri, position, includeDeclaration);
     }
-    async getRename(documentUri, offset, newName) {
-        const code = await this.loadFile(documentUri);
-        if (code === null) {
-            log.error(`expected ${documentUri} to be in the document map`);
-            return undefined;
-        }
-        const convertedOffset = mapUtf16UnitsToUtf8Units([offset], code)[offset];
-        const result = this.languageService.get_rename(documentUri, convertedOffset, newName);
-        const mappedChanges = [];
-        for (const [uri, edits] of result.changes) {
-            const code = await this.loadFile(uri);
-            if (code) {
-                const mappedEdits = edits.map((edit) => {
-                    updateSpanFromUtf8ToUtf16(edit.range, code);
-                    return edit;
-                });
-                mappedChanges.push([uri, mappedEdits]);
-            }
-        }
-        result.changes = mappedChanges;
-        return result;
-    }
-    async prepareRename(documentUri, offset) {
-        const code = await this.loadFile(documentUri);
-        if (code === null) {
-            log.error(`expected ${documentUri} to be in the document map`);
-            return undefined;
-        }
-        const convertedOffset = mapUtf16UnitsToUtf8Units([offset], code)[offset];
-        const result = this.languageService.prepare_rename(documentUri, convertedOffset);
-        if (result) {
-            updateSpanFromUtf8ToUtf16(result.range, code);
-        }
-        return result;
+    async getSignatureHelp(documentUri, position) {
+        return this.languageService.get_signature_help(documentUri, position);
+    }
+    async getRename(documentUri, position, newName) {
+        return this.languageService.get_rename(documentUri, position, newName);
+    }
+    async prepareRename(documentUri, position) {
+        return this.languageService.prepare_rename(documentUri, position);
     }
     async dispose() {
         this.languageService.stop_background_work();
@@ -211,26 +59,11 @@ export class QSharpLanguageService {
     }
     async onDiagnostics(uri, version, diagnostics) {
         try {
-            const code = await this.loadFile(uri);
-            const empty = diagnostics.length === 0;
-            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 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");
             event.detail = {
                 uri,
                 version: version ?? 0,
-                diagnostics: empty ? [] : mapDiagnostics(diagnostics, code),
+                diagnostics,
             };
             this.eventHandler.dispatchEvent(event);
         }
@@ -239,8 +72,3 @@ export class QSharpLanguageService {
         }
     }
 }
-function updateSpanFromUtf8ToUtf16(span, code) {
-    const mappedSpan = mapUtf8UnitsToUtf16Units([span.start, span.end], code);
-    span.start = mappedSpan[span.start];
-    span.end = mappedSpan[span.end];
-}

package/dist/main.d.ts

@@ -15,3 +15,4 @@ export declare function getLanguageService(readFile?: (uri: string) => Promise<s
     manifestDirectory: string;
 } | null>): ILanguageService;
 export declare function getLanguageServiceWorker(): ILanguageServiceWorker;
+export * as utils from "./utils.js";

package/dist/main.js

@@ -89,3 +89,4 @@ export function getLanguageServiceWorker() {
     worker.addListener("message", proxy.onMsgFromWorker);
     return proxy;
 }
+export * as utils from "./utils.js";

package/dist/samples.generated.d.ts

@@ -1,6 +1,12 @@
-declare const _default: {
+declare const _default: ({
     title: string;
     shots: number;
     code: string;
-}[];
+    omitFromTests?: undefined;
+} | {
+    title: string;
+    shots: number;
+    code: string;
+    omitFromTests: boolean;
+})[];
 export default _default;

package/dist/samples.generated.js

@@ -78,5 +78,23 @@ export default [
         "title": "Shor",
         "shots": 1,
         "code": "/// # Sample\n/// Shor's algorithm\n///\n/// # Description\n/// Shor's algorithm is a quantum algorithm for finding the prime factors of an\n/// integer.\n///\n/// This Q# program implements Shor's algorithm.\nnamespace Sample {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Random;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Unstable.Arithmetic;\n    open Microsoft.Quantum.Arrays;\n\n    @EntryPoint()\n    operation Main() : (Int, Int) {\n        let n = 143; // 11*13;\n        // You can try these other examples for a lengthier computation.\n        // let n = 16837; // = 113*149\n        // let n = 22499; // = 149*151\n\n        // Use Shor's algorithm to factor a semiprime integer.\n        let (a, b) = FactorSemiprimeInteger(n);\n        Message($\"Found factorization {n} = {a} * {b} \");\n        return (a, b);\n    }\n\n    /// # Summary\n    /// Uses Shor's algorithm to factor an input number.\n    ///\n    /// # Input\n    /// ## number\n    /// A semiprime integer to be factored.\n    ///\n    /// # Output\n    /// Pair of numbers p > 1 and q > 1 such that p⋅q = `number`\n    operation FactorSemiprimeInteger(number : Int) : (Int, Int) {\n        // First check the most trivial case (the provided number is even).\n        if number % 2 == 0 {\n            Message(\"An even number has been given; 2 is a factor.\");\n            return (number / 2, 2);\n        }\n        // These mutables will keep track of whether we found the factors, and\n        // if so, what they are. The default value for the factors is (1,1).\n        mutable foundFactors = false;\n        mutable factors = (1, 1);\n        mutable attempt = 1;\n        repeat {\n            Message($\"*** Factorizing {number}, attempt {attempt}.\");\n            // Try to guess a number co-prime to `number` by getting a random\n            // integer in the interval [1, number-1]\n            let generator = DrawRandomInt(1, number - 1);\n\n            // Check if the random integer is indeed co-prime.\n            // If true use Quantum algorithm for Period finding.\n            if GreatestCommonDivisorI(generator, number) == 1 {\n                Message($\"Estimating period of {generator}.\");\n\n                // Call Quantum Period finding algorithm for\n                // `generator` mod `number`.\n                let period = EstimatePeriod(generator, number);\n\n                // Set the flag and factors values if the continued\n                // fractions classical algorithm succeeds.\n                set (foundFactors, factors) =\n                    MaybeFactorsFromPeriod(number, generator, period);\n            }\n            // In this case, we guessed a divisor by accident.\n            else {\n                // Find divisor.\n                let gcd = GreatestCommonDivisorI(number, generator);\n                Message($\"We have guessed a divisor {gcd} by accident. \" +\n                    \"No quantum computation was done.\");\n\n                // Set the flag `foundFactors` to true, indicating that we\n                // succeeded in finding factors.\n                set foundFactors = true;\n                set factors = (gcd, number / gcd);\n            }\n            set attempt = attempt+1;\n            if (attempt > 100) {\n                fail \"Failed to find factors: too many attempts!\";\n            }\n        }\n        until foundFactors\n        fixup {\n            Message(\"The estimated period did not yield a valid factor. \" +\n                \"Trying again.\");\n        }\n\n        // Return the factorization\n        return factors;\n    }\n\n    /// # Summary\n    /// Tries to find the factors of `modulus` given a `period` and `generator`.\n    ///\n    /// # Input\n    /// ## modulus\n    /// The modulus which defines the residue ring Z mod `modulus` in which the\n    /// multiplicative order of `generator` is being estimated.\n    /// ## generator\n    /// The unsigned integer multiplicative order (period) of which is being\n    /// estimated. Must be co-prime to `modulus`.\n    /// ## period\n    /// The estimated period (multiplicative order) of the generator mod\n    /// `modulus`.\n    ///\n    /// # Output\n    /// A tuple of a flag indicating whether factors were found successfully,\n    /// and a pair of integers representing the factors that were found.\n    /// Note that the second output is only meaningful when the first output is\n    /// `true`.\n    function MaybeFactorsFromPeriod(\n        modulus : Int,\n        generator : Int,\n        period : Int)\n    : (Bool, (Int, Int)) {\n\n        // Period finding reduces to factoring only if period is even\n        if period % 2 == 0 {\n            // Compute `generator` ^ `period/2` mod `number`.\n            let halfPower = ExpModI(generator, period / 2, modulus);\n\n            // If we are unlucky, halfPower is just -1 mod N, which is a trivial\n            // case and not useful for factoring.\n            if halfPower != modulus - 1 {\n                // When the halfPower is not -1 mod N, halfPower-1 or\n                // halfPower+1 share non-trivial divisor with `number`. Find it.\n                let factor = MaxI(\n                    GreatestCommonDivisorI(halfPower - 1, modulus),\n                    GreatestCommonDivisorI(halfPower + 1, modulus)\n                );\n\n                // Add a flag that we found the factors, and return only if computed\n                // non-trivial factors (not like 1:n or n:1)\n                if (factor != 1) and (factor != modulus) {\n                    Message($\"Found factor={factor}\");\n                    return (true, (factor, modulus / factor));\n                }\n            }\n            // Return a flag indicating we hit a trivial case and didn't get\n            // any factors.\n            Message($\"Found trivial factors.\");\n            return (false, (1, 1));\n        } else {\n            // When period is odd we have to pick another generator to estimate\n            // period of and start over.\n            Message($\"Estimated period {period} was odd, trying again.\");\n            return (false, (1, 1));\n        }\n    }\n\n    /// # Summary\n    /// Find the period of a number from an input frequency.\n    ///\n    /// # Input\n    /// ## modulus\n    /// The modulus which defines the residue ring Z mod `modulus` in which the\n    /// multiplicative order of `generator` is being estimated.\n    /// ## frequencyEstimate\n    /// The frequency that we want to convert to a period.\n    /// ## bitsPrecision\n    /// Number of bits of precision with which we need to estimate s/r to\n    /// recover period r using continued fractions algorithm.\n    /// ## currentDivisor\n    /// The divisor of the generator period found so far.\n    ///\n    /// # Output\n    /// The period as calculated from the estimated frequency via the continued\n    /// fractions algorithm.\n    function PeriodFromFrequency(\n        modulus : Int,\n        frequencyEstimate : Int,\n        bitsPrecision : Int,\n        currentDivisor : Int)\n    : Int {\n        // Now we use the ContinuedFractionConvergentI function to recover s/r\n        // from dyadic fraction k/2^bitsPrecision.\n        let (numerator, period) = ContinuedFractionConvergentI(\n            (frequencyEstimate, 2 ^ bitsPrecision),\n            modulus);\n\n        // ContinuedFractionConvergentI does not guarantee the signs of the\n        // numerator and denominator. Here we make sure that both are positive\n        // using AbsI.\n        let (numeratorAbs, periodAbs) = (AbsI(numerator), AbsI(period));\n\n        // Compute and return the newly found divisor.\n        let period =\n            (periodAbs * currentDivisor) /\n            GreatestCommonDivisorI(currentDivisor, periodAbs);\n        Message($\"Found period={period}\");\n        return period;\n    }\n\n    /// # Summary\n    /// Finds a multiplicative order of the generator in the residue ring Z mod\n    /// `modulus`.\n    ///\n    /// # Input\n    /// ## generator\n    /// The unsigned integer multiplicative order (period) of which is being\n    /// estimated. Must be co-prime to `modulus`.\n    /// ## modulus\n    /// The modulus which defines the residue ring Z mod `modulus` in which the\n    /// multiplicative order of `generator` is being estimated.\n    ///\n    /// # Output\n    /// The period (multiplicative order) of the generator mod `modulus`\n    operation EstimatePeriod(generator : Int, modulus : Int) : Int {\n        // Here we check that the inputs to the EstimatePeriod operation are\n        // valid.\n        Fact(\n            GreatestCommonDivisorI(generator, modulus) == 1,\n            \"`generator` and `modulus` must be co-prime\");\n\n        // Number of bits in the modulus with respect to which we are estimating\n        // the period.\n        let bitsize = BitSizeI(modulus);\n\n        // The EstimatePeriod operation estimates the period r by finding an\n        // approximation k/2^(bits precision) to a fraction s/r, where s is some\n        // integer. Note that if s and r have common divisors we will end up\n        // recovering a divisor of r and not r itself.\n\n        // Number of bits of precision with which we need to estimate s/r to\n        // recover period r, using continued fractions algorithm.\n        let bitsPrecision = 2 * bitsize + 1;\n\n        // Current estimate for the frequency of the form s/r.\n        let frequencyEstimate = EstimateFrequency(generator, modulus, bitsize);\n        if frequencyEstimate != 0 {\n            return PeriodFromFrequency(\n                modulus, frequencyEstimate, bitsPrecision, 1);\n        }\n        else {\n            Message(\"The estimated frequency was 0, trying again.\");\n            return 1;\n        }\n    }\n\n    /// # Summary\n    /// Estimates the frequency of a generator in the residue ring Z mod\n    /// `modulus`.\n    ///\n    /// # Input\n    /// ## generator\n    /// The unsigned integer multiplicative order (period) of which is being\n    /// estimated. Must be co-prime to `modulus`.\n    /// ## modulus\n    /// The modulus which defines the residue ring Z mod `modulus` in which the\n    /// multiplicative order of `generator` is being estimated.\n    /// ## bitsize\n    /// Number of bits needed to represent the modulus.\n    ///\n    /// # Output\n    /// The numerator k of dyadic fraction k/2^bitsPrecision approximating s/r.\n    operation EstimateFrequency(generator : Int,modulus : Int, bitsize : Int)\n    : Int {\n        mutable frequencyEstimate = 0;\n        let bitsPrecision =  2 * bitsize + 1;\n        Message($\"Estimating frequency with bitsPrecision={bitsPrecision}.\");\n\n        // Allocate qubits for the superposition of eigenstates of the oracle\n        // that is used in period finding.\n        use eigenstateRegister = Qubit[bitsize];\n\n        // Initialize eigenstateRegister to 1, which is a superposition of the\n        // eigenstates we are estimating the phases of.\n        // We are interpreting the register as encoding an unsigned integer in\n        // little-endian format.\n        ApplyXorInPlace(1, eigenstateRegister);\n\n        // Use phase estimation with a semiclassical Fourier transform to\n        // estimate the frequency.\n        use c = Qubit();\n        for idx in bitsPrecision-1..-1..0 {\n            H(c);\n            Controlled ApplyOrderFindingOracle(\n                [c],\n                (generator, modulus, 1 <<< idx, eigenstateRegister));\n            R1Frac(frequencyEstimate, bitsPrecision-1-idx, c);\n            H(c);\n            if M(c) == One {\n                X(c); // Reset\n                set frequencyEstimate += 1 <<< (bitsPrecision-1-idx);\n            }\n        }\n\n        // Return all the qubits used for oracle's eigenstate back to 0 state\n        // using ResetAll.\n        ResetAll(eigenstateRegister);\n        Message($\"Estimated frequency={frequencyEstimate}\");\n        return frequencyEstimate;\n    }\n\n    /// # Summary\n    /// Interprets `target` as encoding unsigned little-endian integer k\n    /// and performs transformation |k⟩ ↦ |gᵖ⋅k mod N ⟩ where\n    /// p is `power`, g is `generator` and N is `modulus`.\n    ///\n    /// # Input\n    /// ## generator\n    /// The unsigned integer multiplicative order (period)\n    /// of which is being estimated. Must be co-prime to `modulus`.\n    /// ## modulus\n    /// The modulus which defines the residue ring Z mod `modulus`\n    /// in which the multiplicative order of `generator` is being estimated.\n    /// ## power\n    /// Power of `generator` by which `target` is multiplied.\n    /// ## target\n    /// Register interpreted as little-endian which is multiplied by\n    /// given power of the generator. The multiplication is performed modulo\n    /// `modulus`.\n    internal operation ApplyOrderFindingOracle(\n        generator : Int, modulus : Int, power : Int, target : Qubit[]\n    )\n    : Unit\n    is Adj + Ctl {\n        // The oracle we use for order finding implements |x⟩ ↦ |x⋅a mod N⟩. We\n        // also use `ExpModI` to compute a by which x must be multiplied. Also\n        // note that we interpret target as unsigned integer in little-endian\n        // format.\n        ModularMultiplyByConstant(\n            modulus,\n            ExpModI(generator, power, modulus),\n            target);\n    }\n\n    /// # Summary\n    /// Performs modular in-place multiplication by a classical constant.\n    ///\n    /// # Description\n    /// Given the classical constants `c` and `modulus`, and an input quantum\n    /// register |𝑦⟩ in little-endian format, this operation computes\n    /// `(c*x) % modulus` into |𝑦⟩.\n    ///\n    /// # Input\n    /// ## modulus\n    /// Modulus to use for modular multiplication\n    /// ## c\n    /// Constant by which to multiply |𝑦⟩\n    /// ## y\n    /// Quantum register of target\n    internal operation ModularMultiplyByConstant(modulus : Int, c : Int, y : Qubit[])\n    : Unit is Adj + Ctl {\n        use qs = Qubit[Length(y)];\n        for idx in IndexRange(y) {\n            let shiftedC = (c <<< idx) % modulus;\n            Controlled ModularAddConstant(\n                [y[idx]],\n                (modulus, shiftedC, qs));\n        }\n        for idx in IndexRange(y) {\n            SWAP(y[idx], qs[idx]);\n        }\n        let invC = InverseModI(c, modulus);\n        for idx in IndexRange(y) {\n            let shiftedC = (invC <<< idx) % modulus;\n            Controlled ModularAddConstant(\n                [y[idx]],\n                (modulus, modulus - shiftedC, qs));\n        }\n    }\n\n    /// # Summary\n    /// Performs modular in-place addition of a classical constant into a\n    /// quantum register.\n    ///\n    /// Given the classical constants `c` and `modulus`, and an input quantum\n    /// register |𝑦⟩ in little-endian format, this operation computes\n    /// `(x+c) % modulus` into |𝑦⟩.\n    ///\n    /// # Input\n    /// ## modulus\n    /// Modulus to use for modular addition\n    /// ## c\n    /// Constant to add to |𝑦⟩\n    /// ## y\n    /// Quantum register of target\n    internal operation ModularAddConstant(modulus : Int, c : Int, y : Qubit[])\n    : Unit is Adj + Ctl {\n        body (...) {\n            Controlled ModularAddConstant([], (modulus, c, y));\n        }\n        controlled (ctrls, ...) {\n            // We apply a custom strategy to control this operation instead of\n            // letting the compiler create the controlled variant for us in\n            // which the `Controlled` functor would be distributed over each\n            // operation in the body.\n            //\n            // Here we can use some scratch memory to save ensure that at most\n            // one control qubit is used for costly operations such as\n            // `AddConstant` and `CompareGreaterThenOrEqualConstant`.\n            if Length(ctrls) >= 2 {\n                use control = Qubit();\n                within {\n                    Controlled X(ctrls, control);\n                } apply {\n                    Controlled ModularAddConstant([control], (modulus, c, y));\n                }\n            } else {\n                use carry = Qubit();\n                Controlled IncByI(ctrls, (c, y + [carry]));\n                Controlled Adjoint IncByI(ctrls, (modulus, y + [carry]));\n                Controlled IncByI([carry], (modulus, y));\n                Controlled ApplyIfLessOrEqualL(ctrls, (X, IntAsBigInt(c), y, carry));\n            }\n        }\n    }\n}\n"
+    },
+    {
+        "title": "Dynamics (Resource Estimation)",
+        "shots": 1,
+        "code": "/// # Sample\n/// Quantum Dynamics\n///\n/// # Description\n/// This example demonstrates quantum dynamics in a style tailored for\n/// resource estimation. The sample is specifically the simulation\n/// of an Ising model Hamiltonian on an N1xN2 2D lattice using a\n/// fourth-order Trotter Suzuki product formula, assuming\n/// a 2D qubit architecture with nearest-neighbor connectivity.\n/// The is an example of a program that is not amenable to simulating\n/// classically, but can be run through resource estimation to determine\n/// what size of quantum system would be needed to solve the problem.\nnamespace QuantumDynamics {\n\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Arrays;\n\n\n    @EntryPoint()\n    operation Main() : Unit {\n        // n : Int, m : Int, t: Double, u : Double, tstep : Double\n        \n        let n = 30;\n        let m = 30;\n\n        let J = 1.0;\n        let g = 1.0;\n\n        let totTime = 30.0;\n        let dt = 0.9;\n\n        IsingModel2DSim(n, m, J, g, totTime, dt);\n    }\n\n    /// # Summary\n    /// The function below creates a sequence containing the rotation angles that will be applied with the two operators used in the expansion of the Trotter-Suzuki formula.\n    /// # Input\n    /// ## p (Double) : Constant used for fourth-order formulas\n    /// \n    /// ## dt (Double) : Time-step used to compute rotation angles\n    /// \n    /// ## J (Double) : coefficient for 2-qubit interactions\n    /// \n    /// ## g (Double) : coefficient for transverse field\n    ///\n    /// # Output\n    /// ## values (Double[]) : The list of rotation angles to be applies in sequence with the corresponding operators\n    ///\n    function SetAngleSequence(p : Double, dt : Double, J : Double, g : Double) : Double[] {\n\n        let len1 = 3;\n        let len2 = 3;\n        let valLength = 2*len1+len2+1;\n        mutable values = [0.0, size=valLength];\n\n        let val1 = J*p*dt;\n        let val2 = -g*p*dt;\n        let val3 = J*(1.0 - 3.0*p)*dt/2.0;\n        let val4 = g*(1.0 - 4.0*p)*dt/2.0;\n\n        for i in 0..len1 {\n            \n            if (i % 2 == 0) {\n                set values w/= i <- val1;\n            }\n            else {\n                set values w/= i <- val2;\n            }\n\n        }\n\n        for i in len1+1..len1+len2 {\n            if (i % 2 == 0) {\n                set values w/= i <- val3;\n            }\n            else {\n                set values w/= i <- val4;\n            }\n        }\n\n        for i in len1+len2+1..valLength-1 {\n            if (i % 2 == 0) {\n                set values w/= i <- val1;\n            }\n            else {\n                set values w/= i <- val2;\n            }\n        }\n        return values;\n    }\n\n    /// # Summary\n    /// Applies e^-iX(theta) on all qubits in the 2D lattice as part of simulating the transverse field in the Ising model\n    /// # Input\n    /// ## n (Int) : Lattice size for an n x n lattice\n    /// \n    /// ## qArr (Qubit[][]) : Array of qubits representing the lattice\n    /// \n    /// ## theta (Double) : The angle/time-step for which the unitary simulation is done.\n    /// \n    operation ApplyAllX(n : Int, qArr : Qubit[][], theta : Double) : Unit {\n        // This applies `Rx` with an angle of `2.0 * theta` to all qubits in `qs`\n        // using partial application\n        for row in 0..n-1 {\n            ApplyToEach(Rx(2.0 * theta, _), qArr[row]);\n        }\n    }\n\n    /// # Summary\n    /// Applies e^-iP(theta) where P = Z o Z as part of the repulsion terms.\n    /// # Input\n    /// ## n, m (Int, Int) : Lattice sizes for an n x m lattice\n    /// \n    /// ## qArr (Qubit[]) : Array of qubits representing the lattice\n    /// \n    /// ## theta (Double) : The angle/time-step for which unitary simulation is done.\n    /// \n    /// ## dir (Bool) : Direction is true for vertical direction.\n    ///\n    /// ## grp (Bool) : Group is true for odd starting indices\n    ///\n    operation ApplyDoubleZ(n : Int, m : Int, qArr : Qubit[][], theta : Double, dir : Bool, grp : Bool) : Unit {\n        let start = grp ? 1 | 0;    // Choose either odd or even indices based on group number\n        let P_op = [PauliZ, PauliZ];\n        let c_end = dir ? m-1 | m-2;\n        let r_end = dir ? m-2 | m-1;\n\n        for row in 0..r_end {\n            for col in start..2..c_end {    // Iterate through even or odd columns based on `grp`\n\n                let row2 = dir ? row+1 | row;\n                let col2 = dir ? col | col+1;\n\n                Exp(P_op, theta, [qArr[row][col], qArr[row2][col2]]);\n            }\n        }\n    }\n\n    /// # Summary\n    /// The main function that takes in various parameters and calls the operations needed to simulate fourth order Trotterizatiuon of the Ising Hamiltonian for a given time-step\n    /// # Input\n    /// ## N1, N2 (Int, Int) : Lattice sizes for an N1 x N2 lattice\n    /// \n    /// ## J (Double) : coefficient for 2-qubit interactions\n    /// \n    /// ## g (Double) : coefficient for transverse field\n    ///\n    /// ## totTime (Double) : The total time-step for which unitary simulation is done.\n    ///\n    /// ## dt (Double) : The time the simulation is done for each timestep\n    ///\n    operation IsingModel2DSim(N1 : Int, N2 : Int, J : Double, g : Double, totTime : Double, dt : Double) : Unit {\n        \n        use qs = Qubit[N1*N2];\n        let qubitArray = Chunks(N2, qs); // qubits are re-arranged to be in an N1 x N2 array\n\n        let p = 1.0 / (4.0 - 4.0^(1.0 / 3.0));\n        let t = Ceiling(totTime / dt);\n\n        let seqLen = 10 * t + 1;\n\n        let angSeq = SetAngleSequence(p, dt, J, g);\n\n        for i in 0..seqLen - 1 {\n            let theta = (i==0 or i==seqLen-1) ? J*p*dt/2.0 | angSeq[i%10];\n\n            // for even indexes\n            if i % 2 == 0 {\n                ApplyAllX(N1, qubitArray, theta);\n            } else {\n                // iterate through all possible combinations for `dir` and `grp`.\n                for (dir, grp) in [(true, true), (true, false), (false, true), (false, false)] {\n                    ApplyDoubleZ(N1, N2, qubitArray, theta, dir, grp);\n                }\n            }\n        }\n    }\n\n}\n",
+        "omitFromTests": true
+    },
+    {
+        "title": "Precalculated (Resource Estimation)",
+        "shots": 1,
+        "code": "/// # Sample\n/// Using pre-calculated logical counts for resource estimation\n///\n/// # Description\n/// This sample demonstrates how to use the `AccountForEstimates` function to\n/// estimate the resources required to run a factoring program from pre-calculated\n/// logical counts. The logical counts used in this sample are the ones obtained\n/// for a 2048-bit integer factoring application based on the implementation\n/// described in [[Quantum 5, 433 (2021)](https://quantum-journal.org/papers/q-2021-04-15-433/)].\n/// Our implementation incorporates all techniques described in the paper, except for\n/// carry runways.\nnamespace PrecalculatedEstimates {\n    open Microsoft.Quantum.ResourceEstimation;\n\n    @EntryPoint()\n    operation FactoringFromLogicalCounts() : Unit {\n        use qubits = Qubit[12581];\n\n        AccountForEstimates(\n            [TCount(12), RotationCount(12), RotationDepth(12),\n            CczCount(3731607428), MeasurementCount(1078154040)],\n            PSSPCLayout(), qubits);\n    }\n\n}\n",
+        "omitFromTests": true
+    },
+    {
+        "title": "Shor (Resource Estimation)",
+        "shots": 1,
+        "code": "/// # Sample\n/// Estimating Frequency for Shor's algorithm\n///\n/// # Description\n/// In this sample we concentrate on costing the `EstimateFrequency`\n/// operation, which is the core quantum operation in Shor's algorithm, and\n/// we omit the classical pre- and post-processing. This makes it ideal for\n/// use with the Azure Quantum Resource Estimator.\nnamespace Shors {\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Canon;\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Measurement;\n    open Microsoft.Quantum.Unstable.Arithmetic;\n    open Microsoft.Quantum.ResourceEstimation;\n\n    @EntryPoint()\n    operation RunProgram() : Unit {\n        let bitsize = 31;\n\n        // When chooseing parameters for `EstimateFrequency`, make sure that\n        // generator and modules are not co-prime\n        let _ = EstimateFrequency(11, 2^bitsize - 1, bitsize);\n    }\n\n    /// # Summary\n    /// Estimates the frequency of a generator\n    /// in the residue ring Z mod `modulus`.\n    ///\n    /// # Input\n    /// ## generator\n    /// The unsigned integer multiplicative order (period)\n    /// of which is being estimated. Must be co-prime to `modulus`.\n    /// ## modulus\n    /// The modulus which defines the residue ring Z mod `modulus`\n    /// in which the multiplicative order of `generator` is being estimated.\n    /// ## bitsize\n    /// Number of bits needed to represent the modulus.\n    ///\n    /// # Output\n    /// The numerator k of dyadic fraction k/2^bitsPrecision\n    /// approximating s/r.\n    operation EstimateFrequency(\n        generator : Int,\n        modulus : Int,\n        bitsize : Int\n    )\n    : Int {\n        mutable frequencyEstimate = 0;\n        let bitsPrecision =  2 * bitsize + 1;\n\n        // Allocate qubits for the superposition of eigenstates of\n        // the oracle that is used in period finding.\n        use eigenstateRegister = Qubit[bitsize];\n\n        // Initialize eigenstateRegister to 1, which is a superposition of\n        // the eigenstates we are estimating the phases of.\n        // We first interpret the register as encoding an unsigned integer\n        // in little endian encoding.\n        ApplyXorInPlace(1, eigenstateRegister);\n        let oracle = ApplyOrderFindingOracle(generator, modulus, _, _);\n\n        // Use phase estimation with a semiclassical Fourier transform to\n        // estimate the frequency.\n        use c = Qubit();\n        for idx in bitsPrecision - 1..-1..0 {\n            within {\n                H(c);\n            } apply {\n                // `BeginEstimateCaching` and `EndEstimateCaching` are the operations\n                // exposed by Azure Quantum Resource Estimator. These will instruct\n                // resource counting such that the if-block will be executed\n                // only once, its resources will be cached, and appended in\n                // every other iteration.\n                if BeginEstimateCaching(\"ControlledOracle\", SingleVariant()) {\n                    Controlled oracle([c], (1 <<< idx, eigenstateRegister));\n                    EndEstimateCaching();\n                }\n                R1Frac(frequencyEstimate, bitsPrecision - 1 - idx, c);\n            }\n            if MResetZ(c) == One {\n                set frequencyEstimate += 1 <<< (bitsPrecision - 1 - idx);\n            }\n        }\n\n        // Return all the qubits used for oracle's eigenstate back to 0 state\n        // using Microsoft.Quantum.Intrinsic.ResetAll.\n        ResetAll(eigenstateRegister);\n\n        return frequencyEstimate;\n    }\n\n    /// # Summary\n    /// Interprets `target` as encoding unsigned little-endian integer k\n    /// and performs transformation |k⟩ ↦ |gᵖ⋅k mod N ⟩ where\n    /// p is `power`, g is `generator` and N is `modulus`.\n    ///\n    /// # Input\n    /// ## generator\n    /// The unsigned integer multiplicative order (period)\n    /// of which is being estimated. Must be co-prime to `modulus`.\n    /// ## modulus\n    /// The modulus which defines the residue ring Z mod `modulus`\n    /// in which the multiplicative order of `generator` is being estimated.\n    /// ## power\n    /// Power of `generator` by which `target` is multiplied.\n    /// ## target\n    /// Register interpreted as little-endian which is multiplied by\n    /// given power of the generator. The multiplication is performed modulo\n    /// `modulus`.\n    internal operation ApplyOrderFindingOracle(\n        generator : Int, modulus : Int, power : Int, target : Qubit[]\n    )\n    : Unit\n    is Adj + Ctl {\n        // The oracle we use for order finding implements |x⟩ ↦ |x⋅a mod N⟩. We\n        // also use `ExpModI` to compute a by which x must be multiplied. Also\n        // note that we interpret target as unsigned integer in little-endian\n        // format.\n        ModularMultiplyByConstant(\n            modulus,\n            ExpModI(generator, power, modulus),\n            target);\n    }\n\n    /// # Summary\n    /// Performs modular in-place multiplication by a classical constant.\n    ///\n    /// # Description\n    /// Given the classical constants `c` and `modulus`, and an input quantum\n    /// register |𝑦⟩ in little-endian format, this operation computes\n    /// `(c*x) % modulus` into |𝑦⟩.\n    ///\n    /// # Input\n    /// ## modulus\n    /// Modulus to use for modular multiplication\n    /// ## c\n    /// Constant by which to multiply |𝑦⟩\n    /// ## y\n    /// Quantum register of target\n    internal operation ModularMultiplyByConstant(modulus : Int, c : Int, y : Qubit[])\n    : Unit is Adj + Ctl {\n        use qs = Qubit[Length(y)];\n        for idx in IndexRange(y) {\n            let shiftedC = (c <<< idx) % modulus;\n            Controlled ModularAddConstant(\n                [y[idx]],\n                (modulus, shiftedC, qs));\n        }\n        for idx in IndexRange(y) {\n            SWAP(y[idx], qs[idx]);\n        }\n        let invC = InverseModI(c, modulus);\n        for idx in IndexRange(y) {\n            let shiftedC = (invC <<< idx) % modulus;\n            Controlled ModularAddConstant(\n                [y[idx]],\n                (modulus, modulus - shiftedC, qs));\n        }\n    }\n\n    /// # Summary\n    /// Performs modular in-place addition of a classical constant into a\n    /// quantum register.\n    ///\n    /// Given the classical constants `c` and `modulus`, and an input quantum\n    /// register |𝑦⟩ in little-endian format, this operation computes\n    /// `(x+c) % modulus` into |𝑦⟩.\n    ///\n    /// # Input\n    /// ## modulus\n    /// Modulus to use for modular addition\n    /// ## c\n    /// Constant to add to |𝑦⟩\n    /// ## y\n    /// Quantum register of target\n    internal operation ModularAddConstant(modulus : Int, c : Int, y : Qubit[])\n    : Unit is Adj + Ctl {\n        body (...) {\n            Controlled ModularAddConstant([], (modulus, c, y));\n        }\n        controlled (ctrls, ...) {\n            // We apply a custom strategy to control this operation instead of\n            // letting the compiler create the controlled variant for us in\n            // which the `Controlled` functor would be distributed over each\n            // operation in the body.\n            //\n            // Here we can use some scratch memory to save ensure that at most\n            // one control qubit is used for costly operations such as\n            // `AddConstant` and `CompareGreaterThenOrEqualConstant`.\n            if Length(ctrls) >= 2 {\n                use control = Qubit();\n                within {\n                    Controlled X(ctrls, control);\n                } apply {\n                    Controlled ModularAddConstant([control], (modulus, c, y));\n                }\n            } else {\n                use carry = Qubit();\n                Controlled IncByI(ctrls, (c, y + [carry]));\n                Controlled Adjoint IncByI(ctrls, (modulus, y + [carry]));\n                Controlled IncByI([carry], (modulus, y));\n                Controlled ApplyIfLessOrEqualL(ctrls, (X, IntAsBigInt(c), y, carry));\n            }\n        }\n    }\n}\n",
+        "omitFromTests": true
     }
 ];

package/dist/utils.d.ts

@@ -0,0 +1,24 @@
+export type Tick = {
+    value: number;
+    label: string;
+};
+export declare function CreateIntegerTicks(min: number, max: number): Tick[];
+export declare function CreateTimeTicks(min: number, max: number): Tick[];
+type SeriesOfPoints = Array<{
+    items: Array<{
+        x: number;
+        y: number;
+    }>;
+}>;
+export declare function getMinMaxXYForItems(data: SeriesOfPoints): [number, number, number, number];
+export declare function getRanges(data: SeriesOfPoints, rangeCoefficient: number): {
+    rangeX: {
+        min: number;
+        max: number;
+    };
+    rangeY: {
+        min: number;
+        max: number;
+    };
+};
+export {};

package/dist/{ux/ticks.js → utils.js}

@@ -123,3 +123,26 @@ export function CreateTimeTicks(min, max) {
     }
     return result;
 }
+// Given an array of object, and each of those objects has an 'items' property
+// that is another array of objects with number properties x & y, return a
+// tuple of [minX, maxX, minY, maxY] covering all items given
+export function getMinMaxXYForItems(data) {
+    return data.reduce((priorSeriesResult, curr) => curr.items.reduce((priorItemResult, curr) => [
+        Math.min(priorItemResult[0], curr.x),
+        Math.max(priorItemResult[1], curr.x),
+        Math.min(priorItemResult[2], curr.y),
+        Math.max(priorItemResult[3], curr.y),
+    ], priorSeriesResult), [Number.MAX_VALUE, Number.MIN_VALUE, Number.MAX_VALUE, Number.MIN_VALUE]);
+}
+export function getRanges(data, rangeCoefficient) {
+    const [minX, maxX, minY, maxY] = getMinMaxXYForItems(data);
+    const rangeX = {
+        min: minX / rangeCoefficient,
+        max: maxX * rangeCoefficient,
+    };
+    const rangeY = {
+        min: minY / rangeCoefficient,
+        max: maxY * rangeCoefficient,
+    };
+    return { rangeX, rangeY };
+}

package/lib/node/qsc_wasm.cjs

@@ -740,38 +740,38 @@ class LanguageService {
     }
     /**
     * @param {string} uri
-    * @param {number} offset
+    * @param {IPosition} position
     * @returns {ICompletionList}
     */
-    get_completions(uri, offset) {
+    get_completions(uri, position) {
         const ptr0 = passStringToWasm0(uri, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.languageservice_get_completions(this.__wbg_ptr, ptr0, len0, offset);
+        const ret = wasm.languageservice_get_completions(this.__wbg_ptr, ptr0, len0, addHeapObject(position));
         return takeObject(ret);
     }
     /**
     * @param {string} uri
-    * @param {number} offset
+    * @param {IPosition} position
     * @returns {ILocation | undefined}
     */
-    get_definition(uri, offset) {
+    get_definition(uri, position) {
         const ptr0 = passStringToWasm0(uri, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.languageservice_get_definition(this.__wbg_ptr, ptr0, len0, offset);
+        const ret = wasm.languageservice_get_definition(this.__wbg_ptr, ptr0, len0, addHeapObject(position));
         return takeObject(ret);
     }
     /**
     * @param {string} uri
-    * @param {number} offset
+    * @param {IPosition} position
     * @param {boolean} include_declaration
     * @returns {(ILocation)[]}
     */
-    get_references(uri, offset, include_declaration) {
+    get_references(uri, position, include_declaration) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passStringToWasm0(uri, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
             const len0 = WASM_VECTOR_LEN;
-            wasm.languageservice_get_references(retptr, this.__wbg_ptr, ptr0, len0, offset, include_declaration);
+            wasm.languageservice_get_references(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(position), include_declaration);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var v2 = getArrayJsValueFromWasm0(r0, r1).slice();
@@ -783,49 +783,49 @@ class LanguageService {
     }
     /**
     * @param {string} uri
-    * @param {number} offset
+    * @param {IPosition} position
     * @returns {IHover | undefined}
     */
-    get_hover(uri, offset) {
+    get_hover(uri, position) {
         const ptr0 = passStringToWasm0(uri, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.languageservice_get_hover(this.__wbg_ptr, ptr0, len0, offset);
+        const ret = wasm.languageservice_get_hover(this.__wbg_ptr, ptr0, len0, addHeapObject(position));
         return takeObject(ret);
     }
     /**
     * @param {string} uri
-    * @param {number} offset
+    * @param {IPosition} position
     * @returns {ISignatureHelp | undefined}
     */
-    get_signature_help(uri, offset) {
+    get_signature_help(uri, position) {
         const ptr0 = passStringToWasm0(uri, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.languageservice_get_signature_help(this.__wbg_ptr, ptr0, len0, offset);
+        const ret = wasm.languageservice_get_signature_help(this.__wbg_ptr, ptr0, len0, addHeapObject(position));
         return takeObject(ret);
     }
     /**
     * @param {string} uri
-    * @param {number} offset
+    * @param {IPosition} position
     * @param {string} new_name
     * @returns {IWorkspaceEdit}
     */
-    get_rename(uri, offset, new_name) {
+    get_rename(uri, position, new_name) {
         const ptr0 = passStringToWasm0(uri, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(new_name, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.languageservice_get_rename(this.__wbg_ptr, ptr0, len0, offset, ptr1, len1);
+        const ret = wasm.languageservice_get_rename(this.__wbg_ptr, ptr0, len0, addHeapObject(position), ptr1, len1);
         return takeObject(ret);
     }
     /**
     * @param {string} uri
-    * @param {number} offset
+    * @param {IPosition} position
     * @returns {ITextEdit | undefined}
     */
-    prepare_rename(uri, offset) {
+    prepare_rename(uri, position) {
         const ptr0 = passStringToWasm0(uri, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.languageservice_prepare_rename(this.__wbg_ptr, ptr0, len0, offset);
+        const ret = wasm.languageservice_prepare_rename(this.__wbg_ptr, ptr0, len0, addHeapObject(position));
         return takeObject(ret);
     }
 }
@@ -1260,8 +1260,8 @@ module.exports.__wbindgen_memory = function() {
     return addHeapObject(ret);
 };
 
-module.exports.__wbindgen_closure_wrapper593 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 221, __wbg_adapter_46);
+module.exports.__wbindgen_closure_wrapper598 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 219, __wbg_adapter_46);
     return addHeapObject(ret);
 };