@codingame/monaco-vscode-api 1.85.6 → 2.0.0-v2.1

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/provideInlineCompletions.js

@@ -0,0 +1,253 @@
+import { assertNever } from '../../../../base/common/assert.js';
+import { DeferredPromise } from '../../../../base/common/async.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { SetMap } from '../../../../base/common/map.js';
+import { onUnexpectedExternalError } from '../../../../base/common/errors.js';
+import { Range } from '../../../common/core/range.js';
+import { fixBracketsInLine } from '../../../common/model/bracketPairsTextModelPart/fixBrackets.js';
+import { SingleTextEdit } from './singleTextEdit.js';
+import { getReadonlyEmptyArray } from './utils.js';
+import { SnippetParser, Text } from '../../snippet/browser/snippetParser.js';
+async function provideInlineCompletions(registry, position, model, context, token = CancellationToken.None, languageConfigurationService) {
+    const defaultReplaceRange = getDefaultRange(position, model);
+    const providers = registry.all(model);
+    const multiMap = ( new SetMap());
+    for (const provider of providers) {
+        if (provider.groupId) {
+            multiMap.add(provider.groupId, provider);
+        }
+    }
+    function getPreferredProviders(provider) {
+        if (!provider.yieldsToGroupIds) {
+            return [];
+        }
+        const result = [];
+        for (const groupId of provider.yieldsToGroupIds || []) {
+            const providers = multiMap.get(groupId);
+            for (const p of providers) {
+                result.push(p);
+            }
+        }
+        return result;
+    }
+    const states = ( new Map());
+    const seen = ( new Set());
+    function findPreferredProviderCircle(provider, stack) {
+        stack = [...stack, provider];
+        if (( seen.has(provider))) {
+            return stack;
+        }
+        seen.add(provider);
+        try {
+            const preferred = getPreferredProviders(provider);
+            for (const p of preferred) {
+                const c = findPreferredProviderCircle(p, stack);
+                if (c) {
+                    return c;
+                }
+            }
+        }
+        finally {
+            seen.delete(provider);
+        }
+        return undefined;
+    }
+    function processProvider(provider) {
+        const state = states.get(provider);
+        if (state) {
+            return state;
+        }
+        const circle = findPreferredProviderCircle(provider, []);
+        if (circle) {
+            onUnexpectedExternalError(( new Error(
+                `Inline completions: cyclic yield-to dependency detected. Path: ${( circle.map(s => s.toString ? ( s.toString()) : ('' + s))).join(' -> ')}`
+            )));
+        }
+        const deferredPromise = ( new DeferredPromise());
+        states.set(provider, deferredPromise.p);
+        (async () => {
+            if (!circle) {
+                const preferred = getPreferredProviders(provider);
+                for (const p of preferred) {
+                    const result = await processProvider(p);
+                    if (result && result.items.length > 0) {
+                        return undefined;
+                    }
+                }
+            }
+            try {
+                const completions = await provider.provideInlineCompletions(model, position, context, token);
+                return completions;
+            }
+            catch (e) {
+                onUnexpectedExternalError(e);
+                return undefined;
+            }
+        })().then(c => deferredPromise.complete(c), e => deferredPromise.error(e));
+        return deferredPromise.p;
+    }
+    const providerResults = await Promise.all(( providers.map(
+        async (provider) => ({ provider, completions: await processProvider(provider) })
+    )));
+    const itemsByHash = ( new Map());
+    const lists = [];
+    for (const result of providerResults) {
+        const completions = result.completions;
+        if (!completions) {
+            continue;
+        }
+        const list = ( new InlineCompletionList(completions, result.provider));
+        lists.push(list);
+        for (const item of completions.items) {
+            const inlineCompletionItem = InlineCompletionItem.from(item, list, defaultReplaceRange, model, languageConfigurationService);
+            itemsByHash.set(inlineCompletionItem.hash(), inlineCompletionItem);
+        }
+    }
+    return ( new InlineCompletionProviderResult(Array.from(( itemsByHash.values())), ( new Set(( itemsByHash.keys()))), lists));
+}
+class InlineCompletionProviderResult {
+    constructor(
+    completions, hashs, providerResults) {
+        this.completions = completions;
+        this.hashs = hashs;
+        this.providerResults = providerResults;
+    }
+    has(item) {
+        return ( this.hashs.has(item.hash()));
+    }
+    dispose() {
+        for (const result of this.providerResults) {
+            result.removeRef();
+        }
+    }
+}
+class InlineCompletionList {
+    constructor(inlineCompletions, provider) {
+        this.inlineCompletions = inlineCompletions;
+        this.provider = provider;
+        this.refCount = 1;
+    }
+    addRef() {
+        this.refCount++;
+    }
+    removeRef() {
+        this.refCount--;
+        if (this.refCount === 0) {
+            this.provider.freeInlineCompletions(this.inlineCompletions);
+        }
+    }
+}
+class InlineCompletionItem {
+    static from(inlineCompletion, source, defaultReplaceRange, textModel, languageConfigurationService) {
+        let insertText;
+        let snippetInfo;
+        let range = inlineCompletion.range ? Range.lift(inlineCompletion.range) : defaultReplaceRange;
+        if (typeof inlineCompletion.insertText === 'string') {
+            insertText = inlineCompletion.insertText;
+            if (languageConfigurationService && inlineCompletion.completeBracketPairs) {
+                insertText = closeBrackets(insertText, range.getStartPosition(), textModel, languageConfigurationService);
+                const diff = insertText.length - inlineCompletion.insertText.length;
+                if (diff !== 0) {
+                    range = ( new Range(
+                        range.startLineNumber,
+                        range.startColumn,
+                        range.endLineNumber,
+                        range.endColumn + diff
+                    ));
+                }
+            }
+            snippetInfo = undefined;
+        }
+        else if ('snippet' in inlineCompletion.insertText) {
+            const preBracketCompletionLength = inlineCompletion.insertText.snippet.length;
+            if (languageConfigurationService && inlineCompletion.completeBracketPairs) {
+                inlineCompletion.insertText.snippet = closeBrackets(inlineCompletion.insertText.snippet, range.getStartPosition(), textModel, languageConfigurationService);
+                const diff = inlineCompletion.insertText.snippet.length - preBracketCompletionLength;
+                if (diff !== 0) {
+                    range = ( new Range(
+                        range.startLineNumber,
+                        range.startColumn,
+                        range.endLineNumber,
+                        range.endColumn + diff
+                    ));
+                }
+            }
+            const snippet = ( new SnippetParser()).parse(inlineCompletion.insertText.snippet);
+            if (snippet.children.length === 1 && snippet.children[0] instanceof Text) {
+                insertText = snippet.children[0].value;
+                snippetInfo = undefined;
+            }
+            else {
+                insertText = ( snippet.toString());
+                snippetInfo = {
+                    snippet: inlineCompletion.insertText.snippet,
+                    range: range
+                };
+            }
+        }
+        else {
+            assertNever();
+        }
+        return ( new InlineCompletionItem(
+            insertText,
+            inlineCompletion.command,
+            range,
+            insertText,
+            snippetInfo,
+            inlineCompletion.additionalTextEdits || getReadonlyEmptyArray(),
+            inlineCompletion,
+            source
+        ));
+    }
+    constructor(filterText, command, range, insertText, snippetInfo, additionalTextEdits,
+    sourceInlineCompletion,
+    source) {
+        this.filterText = filterText;
+        this.command = command;
+        this.range = range;
+        this.insertText = insertText;
+        this.snippetInfo = snippetInfo;
+        this.additionalTextEdits = additionalTextEdits;
+        this.sourceInlineCompletion = sourceInlineCompletion;
+        this.source = source;
+        filterText = filterText.replace(/\r\n|\r/g, '\n');
+        insertText = filterText.replace(/\r\n|\r/g, '\n');
+    }
+    withRange(updatedRange) {
+        return ( new InlineCompletionItem(
+            this.filterText,
+            this.command,
+            updatedRange,
+            this.insertText,
+            this.snippetInfo,
+            this.additionalTextEdits,
+            this.sourceInlineCompletion,
+            this.source
+        ));
+    }
+    hash() {
+        return JSON.stringify({ insertText: this.insertText, range: ( this.range.toString()) });
+    }
+    toSingleTextEdit() {
+        return ( new SingleTextEdit(this.range, this.insertText));
+    }
+}
+function getDefaultRange(position, model) {
+    const word = model.getWordAtPosition(position);
+    const maxColumn = model.getLineMaxColumn(position.lineNumber);
+    return word
+        ? ( new Range(position.lineNumber, word.startColumn, position.lineNumber, maxColumn))
+        : Range.fromPositions(position, position.with(undefined, maxColumn));
+}
+function closeBrackets(text, position, model, languageConfigurationService) {
+    const lineStart = model.getLineContent(position.lineNumber).substring(0, position.column - 1);
+    const newLine = lineStart + text;
+    const newTokens = model.tokenization.tokenizeLineWithEdit(position, newLine.length - (position.column - 1), text);
+    const slicedTokens = newTokens?.sliceAndInflate(position.column - 1, newLine.length, 0);
+    if (!slicedTokens) {
+        return text;
+    }
+    const newText = fixBracketsInLine(slicedTokens, languageConfigurationService);
+    return newText;
+}
+export { InlineCompletionItem, InlineCompletionList, InlineCompletionProviderResult, provideInlineCompletions };

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/singleTextEdit.js

@@ -0,0 +1,172 @@
+import { LcsDiff } from '../../../../base/common/diff/diff.js';
+import { commonPrefixLength, getLeadingWhitespace, splitLines } from '../../../../base/common/strings.js';
+import { Range } from '../../../common/core/range.js';
+import { GhostTextPart, GhostText } from './ghostText.js';
+import { addPositions, lengthOfText } from './utils.js';
+class SingleTextEdit {
+    constructor(range, text) {
+        this.range = range;
+        this.text = text;
+    }
+    removeCommonPrefix(model, validModelRange) {
+        const modelRange = validModelRange ? this.range.intersectRanges(validModelRange) : this.range;
+        if (!modelRange) {
+            return this;
+        }
+        const valueToReplace = model.getValueInRange(modelRange, 1 );
+        const commonPrefixLen = commonPrefixLength(valueToReplace, this.text);
+        const start = addPositions(this.range.getStartPosition(), lengthOfText(valueToReplace.substring(0, commonPrefixLen)));
+        const text = this.text.substring(commonPrefixLen);
+        const range = Range.fromPositions(start, this.range.getEndPosition());
+        return ( new SingleTextEdit(range, text));
+    }
+    augments(base) {
+        return this.text.startsWith(base.text) && rangeExtends(this.range, base.range);
+    }
+    computeGhostText(model, mode, cursorPosition, previewSuffixLength = 0) {
+        let edit = this.removeCommonPrefix(model);
+        if (edit.range.endLineNumber !== edit.range.startLineNumber) {
+            return undefined;
+        }
+        const sourceLine = model.getLineContent(edit.range.startLineNumber);
+        const sourceIndentationLength = getLeadingWhitespace(sourceLine).length;
+        const suggestionTouchesIndentation = edit.range.startColumn - 1 <= sourceIndentationLength;
+        if (suggestionTouchesIndentation) {
+            const suggestionAddedIndentationLength = getLeadingWhitespace(edit.text).length;
+            const replacedIndentation = sourceLine.substring(edit.range.startColumn - 1, sourceIndentationLength);
+            const [startPosition, endPosition] = [edit.range.getStartPosition(), edit.range.getEndPosition()];
+            const newStartPosition = startPosition.column + replacedIndentation.length <= endPosition.column
+                ? startPosition.delta(0, replacedIndentation.length)
+                : endPosition;
+            const rangeThatDoesNotReplaceIndentation = Range.fromPositions(newStartPosition, endPosition);
+            const suggestionWithoutIndentationChange = edit.text.startsWith(replacedIndentation)
+                ? edit.text.substring(replacedIndentation.length)
+                : edit.text.substring(suggestionAddedIndentationLength);
+            edit = ( new SingleTextEdit(rangeThatDoesNotReplaceIndentation, suggestionWithoutIndentationChange));
+        }
+        const valueToBeReplaced = model.getValueInRange(edit.range);
+        const changes = cachingDiff(valueToBeReplaced, edit.text);
+        if (!changes) {
+            return undefined;
+        }
+        const lineNumber = edit.range.startLineNumber;
+        const parts = ( new Array());
+        if (mode === 'prefix') {
+            const filteredChanges = changes.filter(c => c.originalLength === 0);
+            if (filteredChanges.length > 1 || filteredChanges.length === 1 && filteredChanges[0].originalStart !== valueToBeReplaced.length) {
+                return undefined;
+            }
+        }
+        const previewStartInCompletionText = edit.text.length - previewSuffixLength;
+        for (const c of changes) {
+            const insertColumn = edit.range.startColumn + c.originalStart + c.originalLength;
+            if (mode === 'subwordSmart' && cursorPosition && cursorPosition.lineNumber === edit.range.startLineNumber && insertColumn < cursorPosition.column) {
+                return undefined;
+            }
+            if (c.originalLength > 0) {
+                return undefined;
+            }
+            if (c.modifiedLength === 0) {
+                continue;
+            }
+            const modifiedEnd = c.modifiedStart + c.modifiedLength;
+            const nonPreviewTextEnd = Math.max(c.modifiedStart, Math.min(modifiedEnd, previewStartInCompletionText));
+            const nonPreviewText = edit.text.substring(c.modifiedStart, nonPreviewTextEnd);
+            const italicText = edit.text.substring(nonPreviewTextEnd, Math.max(c.modifiedStart, modifiedEnd));
+            if (nonPreviewText.length > 0) {
+                const lines = splitLines(nonPreviewText);
+                parts.push(( new GhostTextPart(insertColumn, lines, false)));
+            }
+            if (italicText.length > 0) {
+                const lines = splitLines(italicText);
+                parts.push(( new GhostTextPart(insertColumn, lines, true)));
+            }
+        }
+        return ( new GhostText(lineNumber, parts));
+    }
+}
+function rangeExtends(extendingRange, rangeToExtend) {
+    return rangeToExtend.getStartPosition().equals(extendingRange.getStartPosition())
+        && rangeToExtend.getEndPosition().isBeforeOrEqual(extendingRange.getEndPosition());
+}
+let lastRequest = undefined;
+function cachingDiff(originalValue, newValue) {
+    if (lastRequest?.originalValue === originalValue && lastRequest?.newValue === newValue) {
+        return lastRequest?.changes;
+    }
+    else {
+        let changes = smartDiff(originalValue, newValue, true);
+        if (changes) {
+            const deletedChars = deletedCharacters(changes);
+            if (deletedChars > 0) {
+                const newChanges = smartDiff(originalValue, newValue, false);
+                if (newChanges && deletedCharacters(newChanges) < deletedChars) {
+                    changes = newChanges;
+                }
+            }
+        }
+        lastRequest = {
+            originalValue,
+            newValue,
+            changes
+        };
+        return changes;
+    }
+}
+function deletedCharacters(changes) {
+    let sum = 0;
+    for (const c of changes) {
+        sum += c.originalLength;
+    }
+    return sum;
+}
+function smartDiff(originalValue, newValue, smartBracketMatching) {
+    if (originalValue.length > 5000 || newValue.length > 5000) {
+        return undefined;
+    }
+    function getMaxCharCode(val) {
+        let maxCharCode = 0;
+        for (let i = 0, len = val.length; i < len; i++) {
+            const charCode = val.charCodeAt(i);
+            if (charCode > maxCharCode) {
+                maxCharCode = charCode;
+            }
+        }
+        return maxCharCode;
+    }
+    const maxCharCode = Math.max(getMaxCharCode(originalValue), getMaxCharCode(newValue));
+    function getUniqueCharCode(id) {
+        if (id < 0) {
+            throw new Error('unexpected');
+        }
+        return maxCharCode + id + 1;
+    }
+    function getElements(source) {
+        let level = 0;
+        let group = 0;
+        const characters = ( new Int32Array(source.length));
+        for (let i = 0, len = source.length; i < len; i++) {
+            if (smartBracketMatching && source[i] === '(') {
+                const id = group * 100 + level;
+                characters[i] = getUniqueCharCode(2 * id);
+                level++;
+            }
+            else if (smartBracketMatching && source[i] === ')') {
+                level = Math.max(level - 1, 0);
+                const id = group * 100 + level;
+                characters[i] = getUniqueCharCode(2 * id + 1);
+                if (level === 0) {
+                    group++;
+                }
+            }
+            else {
+                characters[i] = source.charCodeAt(i);
+            }
+        }
+        return characters;
+    }
+    const elements1 = getElements(originalValue);
+    const elements2 = getElements(newValue);
+    return ( new LcsDiff({ getElements: () => elements1 }, { getElements: () => elements2 })).ComputeDiff(false).changes;
+}
+export { SingleTextEdit };

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/suggestWidgetInlineCompletionProvider.js

@@ -0,0 +1,182 @@
+import { Event } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { Position } from '../../../common/core/position.js';
+import { Range } from '../../../common/core/range.js';
+import { SelectedSuggestionInfo } from '../../../common/languages.js';
+import { SnippetParser } from '../../snippet/browser/snippetParser.js';
+import { SnippetSession } from '../../snippet/browser/snippetSession.js';
+import { SuggestController } from '../../suggest/browser/suggestController.js';
+import { SingleTextEdit } from './singleTextEdit.js';
+import { compareBy, numberComparator } from '../../../../base/common/arrays.js';
+import { findFirstMaxBy } from '../../../../base/common/arraysFind.js';
+import { observableValue, transaction } from '../../../../base/common/observableInternal/base.js';
+class SuggestWidgetAdaptor extends Disposable {
+    get selectedItem() {
+        return this._selectedItem;
+    }
+    constructor(editor, suggestControllerPreselector, checkModelVersion, onWillAccept) {
+        super();
+        this.editor = editor;
+        this.suggestControllerPreselector = suggestControllerPreselector;
+        this.checkModelVersion = checkModelVersion;
+        this.onWillAccept = onWillAccept;
+        this.isSuggestWidgetVisible = false;
+        this.isShiftKeyPressed = false;
+        this._isActive = false;
+        this._currentSuggestItemInfo = undefined;
+        this._selectedItem = observableValue(this, undefined);
+        this._register(editor.onKeyDown(e => {
+            if (e.shiftKey && !this.isShiftKeyPressed) {
+                this.isShiftKeyPressed = true;
+                this.update(this._isActive);
+            }
+        }));
+        this._register(editor.onKeyUp(e => {
+            if (e.shiftKey && this.isShiftKeyPressed) {
+                this.isShiftKeyPressed = false;
+                this.update(this._isActive);
+            }
+        }));
+        const suggestController = SuggestController.get(this.editor);
+        if (suggestController) {
+            this._register(suggestController.registerSelector({
+                priority: 100,
+                select: (model, pos, suggestItems) => {
+                    transaction(tx => this.checkModelVersion(tx));
+                    const textModel = this.editor.getModel();
+                    if (!textModel) {
+                        return -1;
+                    }
+                    const itemToPreselect = this.suggestControllerPreselector()?.removeCommonPrefix(textModel);
+                    if (!itemToPreselect) {
+                        return -1;
+                    }
+                    const position = Position.lift(pos);
+                    const candidates = ( suggestItems
+                        .map((suggestItem, index) => {
+                        const suggestItemInfo = SuggestItemInfo.fromSuggestion(suggestController, textModel, position, suggestItem, this.isShiftKeyPressed);
+                        const suggestItemTextEdit = suggestItemInfo.toSingleTextEdit().removeCommonPrefix(textModel);
+                        const valid = itemToPreselect.augments(suggestItemTextEdit);
+                        return { index, valid, prefixLength: suggestItemTextEdit.text.length, suggestItem };
+                    }))
+                        .filter(item => item && item.valid && item.prefixLength > 0);
+                    const result = findFirstMaxBy(candidates, compareBy(s => s.prefixLength, numberComparator));
+                    return result ? result.index : -1;
+                }
+            }));
+            let isBoundToSuggestWidget = false;
+            const bindToSuggestWidget = () => {
+                if (isBoundToSuggestWidget) {
+                    return;
+                }
+                isBoundToSuggestWidget = true;
+                this._register(suggestController.widget.value.onDidShow(() => {
+                    this.isSuggestWidgetVisible = true;
+                    this.update(true);
+                }));
+                this._register(suggestController.widget.value.onDidHide(() => {
+                    this.isSuggestWidgetVisible = false;
+                    this.update(false);
+                }));
+                this._register(suggestController.widget.value.onDidFocus(() => {
+                    this.isSuggestWidgetVisible = true;
+                    this.update(true);
+                }));
+            };
+            this._register(Event.once(suggestController.model.onDidTrigger)(e => {
+                bindToSuggestWidget();
+            }));
+            this._register(suggestController.onWillInsertSuggestItem(e => {
+                const position = this.editor.getPosition();
+                const model = this.editor.getModel();
+                if (!position || !model) {
+                    return undefined;
+                }
+                const suggestItemInfo = SuggestItemInfo.fromSuggestion(suggestController, model, position, e.item, this.isShiftKeyPressed);
+                this.onWillAccept(suggestItemInfo);
+            }));
+        }
+        this.update(this._isActive);
+    }
+    update(newActive) {
+        const newInlineCompletion = this.getSuggestItemInfo();
+        if (this._isActive !== newActive || !suggestItemInfoEquals(this._currentSuggestItemInfo, newInlineCompletion)) {
+            this._isActive = newActive;
+            this._currentSuggestItemInfo = newInlineCompletion;
+            transaction(tx => {
+                this.checkModelVersion(tx);
+                this._selectedItem.set(this._isActive ? this._currentSuggestItemInfo : undefined, tx);
+            });
+        }
+    }
+    getSuggestItemInfo() {
+        const suggestController = SuggestController.get(this.editor);
+        if (!suggestController || !this.isSuggestWidgetVisible) {
+            return undefined;
+        }
+        const focusedItem = suggestController.widget.value.getFocusedItem();
+        const position = this.editor.getPosition();
+        const model = this.editor.getModel();
+        if (!focusedItem || !position || !model) {
+            return undefined;
+        }
+        return SuggestItemInfo.fromSuggestion(suggestController, model, position, focusedItem.item, this.isShiftKeyPressed);
+    }
+    stopForceRenderingAbove() {
+        const suggestController = SuggestController.get(this.editor);
+        suggestController?.stopForceRenderingAbove();
+    }
+    forceRenderingAbove() {
+        const suggestController = SuggestController.get(this.editor);
+        suggestController?.forceRenderingAbove();
+    }
+}
+class SuggestItemInfo {
+    static fromSuggestion(suggestController, model, position, item, toggleMode) {
+        let { insertText } = item.completion;
+        let isSnippetText = false;
+        if (item.completion.insertTextRules & 4 ) {
+            const snippet = ( new SnippetParser()).parse(insertText);
+            if (snippet.children.length < 100) {
+                SnippetSession.adjustWhitespace(model, position, true, snippet);
+            }
+            insertText = ( snippet.toString());
+            isSnippetText = true;
+        }
+        const info = suggestController.getOverwriteInfo(item, toggleMode);
+        return ( new SuggestItemInfo(
+            Range.fromPositions(position.delta(0, -info.overwriteBefore), position.delta(0, Math.max(info.overwriteAfter, 0))),
+            insertText,
+            item.completion.kind,
+            isSnippetText
+        ));
+    }
+    constructor(range, insertText, completionItemKind, isSnippetText) {
+        this.range = range;
+        this.insertText = insertText;
+        this.completionItemKind = completionItemKind;
+        this.isSnippetText = isSnippetText;
+    }
+    equals(other) {
+        return this.range.equalsRange(other.range)
+            && this.insertText === other.insertText
+            && this.completionItemKind === other.completionItemKind
+            && this.isSnippetText === other.isSnippetText;
+    }
+    toSelectedSuggestionInfo() {
+        return ( new SelectedSuggestionInfo(this.range, this.insertText, this.completionItemKind, this.isSnippetText));
+    }
+    toSingleTextEdit() {
+        return ( new SingleTextEdit(this.range, this.insertText));
+    }
+}
+function suggestItemInfoEquals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (!a || !b) {
+        return false;
+    }
+    return a.equals(b);
+}
+export { SuggestItemInfo, SuggestWidgetAdaptor };