@codingame/monaco-vscode-treesitter-service-override 15.0.2 → 16.0.0

package/vscode/src/vs/editor/common/services/treeSitter/treeSitterParserService.js

@@ -1,495 +1,28 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { nodeModulesPath, FileAccess } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { FileAccess } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 import { EDITOR_EXPERIMENTAL_PREFER_TREESITTER, TREESITTER_ALLOWED_SUPPORT } from '../treeSitterParserService.js';
 import { ITreeSitterImporter } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitterParserService.service';
 import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
-import { Disposable, DisposableStore, dispose, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
-import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
-import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { setTimeout0 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
-import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { cancelOnDispose } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
-import { isCancellationError, CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
-import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
-import { Position } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position';
-import { LimitedQueue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { TextLength } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/textLength';
-import { PromiseResult } from '@codingame/monaco-vscode-168b98e5-dc20-5807-b1f9-798f1f92b37f-common/vscode/vs/base/common/observableInternal/promise';
+import { TextModelTreeSitter } from './textModelTreeSitter.js';
+import { TreeSitterLanguages, getModuleLocation } from './treeSitterLanguages.js';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 
 const EDITOR_TREESITTER_TELEMETRY = 'editor.experimental.treeSitterTelemetry';
-const MODULE_LOCATION_SUBPATH = `@vscode/tree-sitter-wasm/wasm`;
 const FILENAME_TREESITTER_WASM = `tree-sitter.wasm`;
-function getModuleLocation(environmentService) {
-    return `${nodeModulesPath}/${MODULE_LOCATION_SUBPATH}`;
-}
-class TextModelTreeSitter extends Disposable {
-    get parseResult() { return this._parseResult; }
-    constructor(model, _treeSitterLanguages, _treeSitterImporter, _logService, _telemetryService, parseImmediately = true) {
-        super();
-        this.model = model;
-        this._treeSitterLanguages = _treeSitterLanguages;
-        this._treeSitterImporter = _treeSitterImporter;
-        this._logService = _logService;
-        this._telemetryService = _telemetryService;
-        this._onDidChangeParseResult = this._register(( new Emitter()));
-        this.onDidChangeParseResult = this._onDidChangeParseResult.event;
-        this._versionId = 0;
-        this._parseSessionDisposables = this._register(( new DisposableStore()));
-        if (parseImmediately) {
-            this._register(Event.runAndSubscribe(this.model.onDidChangeLanguage, (e => this._onDidChangeLanguage(e ? e.newLanguage : this.model.getLanguageId()))));
-        }
-        else {
-            this._register(this.model.onDidChangeLanguage(e => this._onDidChangeLanguage(e ? e.newLanguage : this.model.getLanguageId())));
-        }
-    }
-    async _onDidChangeLanguage(languageId) {
-        this.parse(languageId);
-    }
-    async parse(languageId = this.model.getLanguageId()) {
-        this._parseSessionDisposables.clear();
-        this._parseResult = undefined;
-        const token = cancelOnDispose(this._parseSessionDisposables);
-        let language;
-        try {
-            language = await this._getLanguage(languageId, token);
-        }
-        catch (e) {
-            if (isCancellationError(e)) {
-                return;
-            }
-            throw e;
-        }
-        const Parser = await this._treeSitterImporter.getParserClass();
-        if (token.isCancellationRequested) {
-            return;
-        }
-        const treeSitterTree = this._parseSessionDisposables.add(( new TreeSitterParseResult(( new Parser()), language, this._logService, this._telemetryService)));
-        this._parseResult = treeSitterTree;
-        this._parseSessionDisposables.add(treeSitterTree.onDidUpdate(e => {
-            if (e.ranges && (e.versionId > this._versionId)) {
-                this._versionId = e.versionId;
-                this._onDidChangeParseResult.fire({ ranges: e.ranges, versionId: e.versionId });
-            }
-        }));
-        this._parseSessionDisposables.add(this.model.onDidChangeContent(e => this._onDidChangeContent(treeSitterTree, e)));
-        this._onDidChangeContent(treeSitterTree, undefined);
-        if (token.isCancellationRequested) {
-            return;
-        }
-        return this._parseResult;
-    }
-    _getLanguage(languageId, token) {
-        const language = this._treeSitterLanguages.getOrInitLanguage(languageId);
-        if (language) {
-            return Promise.resolve(language);
-        }
-        const disposables = [];
-        return ( new Promise((resolve, reject) => {
-            disposables.push(this._treeSitterLanguages.onDidAddLanguage(e => {
-                if (e.id === languageId) {
-                    dispose(disposables);
-                    resolve(e.language);
-                }
-            }));
-            token.onCancellationRequested(() => {
-                dispose(disposables);
-                reject(( new CancellationError()));
-            }, undefined, disposables);
-        }));
-    }
-    _onDidChangeContent(treeSitterTree, change) {
-        return treeSitterTree.onDidChangeContent(this.model, change);
-    }
-}
-var TelemetryParseType;
-(function (TelemetryParseType) {
-    TelemetryParseType["Full"] = "fullParse";
-    TelemetryParseType["Incremental"] = "incrementalParse";
-})(TelemetryParseType || (TelemetryParseType = {}));
-class TreeSitterParseResult {
-    get versionId() {
-        return this._versionId;
-    }
-    constructor(parser, language, _logService, _telemetryService) {
-        this.parser = parser;
-        this.language = language;
-        this._logService = _logService;
-        this._telemetryService = _telemetryService;
-        this._onDidUpdate = ( new Emitter());
-        this.onDidUpdate = this._onDidUpdate.event;
-        this._versionId = 0;
-        this._editVersion = 0;
-        this._isDisposed = false;
-        this._onDidChangeContentQueue = ( new LimitedQueue());
-        this._lastYieldTime = 0;
-        this.parser.setLanguage(language);
-    }
-    dispose() {
-        this._isDisposed = true;
-        this._onDidUpdate.dispose();
-        this._tree?.delete();
-        this._lastFullyParsed?.delete();
-        this._lastFullyParsedWithEdits?.delete();
-        this.parser?.delete();
-    }
-    get tree() { return this._lastFullyParsed; }
-    get isDisposed() { return this._isDisposed; }
-    findChangedNodes(newTree, oldTree) {
-        const newCursor = newTree.walk();
-        const oldCursor = oldTree.walk();
-        const gotoNextSibling = () => {
-            const n = newCursor.gotoNextSibling();
-            const o = oldCursor.gotoNextSibling();
-            if (n !== o) {
-                throw ( new Error('Trees are out of sync'));
-            }
-            return n && o;
-        };
-        const gotoParent = () => {
-            const n = newCursor.gotoParent();
-            const o = oldCursor.gotoParent();
-            if (n !== o) {
-                throw ( new Error('Trees are out of sync'));
-            }
-            return n && o;
-        };
-        const gotoNthChild = (index) => {
-            const n = newCursor.gotoFirstChild();
-            const o = oldCursor.gotoFirstChild();
-            if (n !== o) {
-                throw ( new Error('Trees are out of sync'));
-            }
-            if (index === 0) {
-                return n && o;
-            }
-            for (let i = 1; i <= index; i++) {
-                const nn = newCursor.gotoNextSibling();
-                const oo = oldCursor.gotoNextSibling();
-                if (nn !== oo) {
-                    throw ( new Error('Trees are out of sync'));
-                }
-                if (!nn || !oo) {
-                    return false;
-                }
-            }
-            return n && o;
-        };
-        const changedRanges = [];
-        let next = true;
-        const nextSiblingOrParentSibling = () => {
-            do {
-                if (newCursor.currentNode.nextSibling) {
-                    return gotoNextSibling();
-                }
-                if (newCursor.currentNode.parent) {
-                    gotoParent();
-                }
-            } while (newCursor.currentNode.nextSibling || newCursor.currentNode.parent);
-            return false;
-        };
-        const getClosestPreviousNodes = () => {
-            const newFindPrev = newTree.walk();
-            newFindPrev.resetTo(newCursor);
-            const oldFindPrev = oldTree.walk();
-            oldFindPrev.resetTo(oldCursor);
-            const startingNode = newCursor.currentNode;
-            do {
-                if (newFindPrev.currentNode.previousSibling && ((newFindPrev.currentNode.endIndex - newFindPrev.currentNode.startIndex) !== 0)) {
-                    newFindPrev.gotoPreviousSibling();
-                    oldFindPrev.gotoPreviousSibling();
-                }
-                else {
-                    while (!newFindPrev.currentNode.previousSibling && newFindPrev.currentNode.parent) {
-                        newFindPrev.gotoParent();
-                        oldFindPrev.gotoParent();
-                    }
-                    newFindPrev.gotoPreviousSibling();
-                    oldFindPrev.gotoPreviousSibling();
-                }
-            } while ((newFindPrev.currentNode.endIndex > startingNode.startIndex)
-                && (newFindPrev.currentNode.parent || newFindPrev.currentNode.previousSibling)
-                && (newFindPrev.currentNode.id !== startingNode.id));
-            if ((newFindPrev.currentNode.id !== startingNode.id) && newFindPrev.currentNode.endIndex <= startingNode.startIndex) {
-                return { old: oldFindPrev.currentNode, new: newFindPrev.currentNode };
-            }
-            else {
-                return undefined;
-            }
-        };
-        do {
-            if (newCursor.currentNode.hasChanges) {
-                const newChildren = newCursor.currentNode.children;
-                const indexChangedChildren = [];
-                const changedChildren = newChildren.filter((c, index) => {
-                    if (c?.hasChanges) {
-                        indexChangedChildren.push(index);
-                    }
-                    return c?.hasChanges;
-                });
-                if ((changedChildren.length === 0) || oldCursor.currentNode.hasError) {
-                    while (newCursor.currentNode.parent && !newCursor.currentNode.isNamed && next) {
-                        next = gotoParent();
-                    }
-                    const newNode = newCursor.currentNode;
-                    const oldNode = oldCursor.currentNode;
-                    const newEndPosition = ( new Position(newNode.endPosition.row + 1, newNode.endPosition.column + 1));
-                    const oldEndIndex = oldNode.endIndex;
-                    const closestPrev = getClosestPreviousNodes();
-                    const newStartPosition = ( new Position(
-                        closestPrev ? closestPrev.new.endPosition.row + 1 : newNode.startPosition.row + 1,
-                        closestPrev ? closestPrev.new.endPosition.column + 1 : newNode.startPosition.column + 1
-                    ));
-                    const newStartIndex = closestPrev ? closestPrev.new.endIndex : newNode.startIndex;
-                    const oldStartIndex = closestPrev ? closestPrev.old.endIndex : oldNode.startIndex;
-                    changedRanges.push({ newStartPosition, newEndPosition, oldStartIndex, oldEndIndex, newNodeId: newNode.id, newStartIndex, newEndIndex: newNode.endIndex });
-                    next = nextSiblingOrParentSibling();
-                }
-                else if (changedChildren.length >= 1) {
-                    next = gotoNthChild(indexChangedChildren[0]);
-                }
-            }
-            else {
-                next = nextSiblingOrParentSibling();
-            }
-        } while (next);
-        if (changedRanges.length === 0 && newTree.rootNode.hasChanges) {
-            return [{ newStartPosition: ( new Position(
-                newTree.rootNode.startPosition.row + 1,
-                newTree.rootNode.startPosition.column + 1
-            )), newEndPosition: ( new Position(
-                newTree.rootNode.endPosition.row + 1,
-                newTree.rootNode.endPosition.column + 1
-            )), oldStartIndex: oldTree.rootNode.startIndex, oldEndIndex: oldTree.rootNode.endIndex, newStartIndex: newTree.rootNode.startIndex, newEndIndex: newTree.rootNode.endIndex, newNodeId: newTree.rootNode.id }];
-        }
-        else {
-            return changedRanges;
-        }
-    }
-    calculateRangeChange(model, changedNodes) {
-        if (!changedNodes) {
-            return undefined;
-        }
-        const ranges = [];
-        for (let i = 0; i < changedNodes.length; i++) {
-            const node = changedNodes[i];
-            const prevNode = changedNodes[i - 1];
-            if ((i > 0) && prevNode.newEndPosition.equals(node.newStartPosition)) {
-                const prevRangeChange = ranges[ranges.length - 1];
-                prevRangeChange.newRange = ( new Range(
-                    prevRangeChange.newRange.startLineNumber,
-                    prevRangeChange.newRange.startColumn,
-                    node.newEndPosition.lineNumber,
-                    node.newEndPosition.column
-                ));
-                prevRangeChange.oldRangeLength = node.oldEndIndex - prevNode.oldStartIndex;
-                prevRangeChange.newRangeEndOffset = node.newEndIndex;
-            }
-            else {
-                ranges.push({ newRange: Range.fromPositions(node.newStartPosition, node.newEndPosition), oldRangeLength: node.oldEndIndex - node.oldStartIndex, newRangeStartOffset: node.newStartIndex, newRangeEndOffset: node.newEndIndex });
-            }
-        }
-        if (ranges.length > 0) {
-            const lastRange = ranges[ranges.length - 1];
-            const maxLine = model.getLineCount();
-            if (lastRange.newRange.endLineNumber > maxLine) {
-                lastRange.newRange = ( new Range(
-                    lastRange.newRange.startLineNumber,
-                    lastRange.newRange.startColumn,
-                    maxLine,
-                    model.getLineMaxColumn(maxLine)
-                ));
-            }
-        }
-        return ranges;
-    }
-    onDidChangeContent(model, changes) {
-        const version = model.getVersionId();
-        if (version === this._editVersion) {
-            return;
-        }
-        this._applyEdits(changes?.changes ?? [], version);
-        this._onDidChangeContentQueue.queue(async () => {
-            if (this.isDisposed) {
-                return;
-            }
-            let ranges;
-            if (this._lastFullyParsedWithEdits && this._lastFullyParsed) {
-                ranges = this.calculateRangeChange(model, this.findChangedNodes(this._lastFullyParsedWithEdits, this._lastFullyParsed));
-            }
-            const completed = await this._parseAndUpdateTree(model, version);
-            if (completed) {
-                if (!ranges) {
-                    ranges = [{ newRange: model.getFullModelRange(), oldRangeLength: model.getValueLength(), newRangeStartOffset: 0, newRangeEndOffset: model.getValueLength() }];
-                }
-                this._onDidUpdate.fire({ ranges, versionId: version });
-            }
-        });
-    }
-    _applyEdits(changes, version) {
-        for (const change of changes) {
-            const originalTextLength = TextLength.ofRange(Range.lift(change.range));
-            const newTextLength = TextLength.ofText(change.text);
-            const summedTextLengths = change.text.length === 0 ? newTextLength : originalTextLength.add(newTextLength);
-            const edit = {
-                startIndex: change.rangeOffset,
-                oldEndIndex: change.rangeOffset + change.rangeLength,
-                newEndIndex: change.rangeOffset + change.text.length,
-                startPosition: { row: change.range.startLineNumber - 1, column: change.range.startColumn - 1 },
-                oldEndPosition: { row: change.range.endLineNumber - 1, column: change.range.endColumn - 1 },
-                newEndPosition: { row: change.range.startLineNumber + summedTextLengths.lineCount - 1, column: summedTextLengths.lineCount ? summedTextLengths.columnCount : (change.range.endColumn + summedTextLengths.columnCount) }
-            };
-            this._tree?.edit(edit);
-            this._lastFullyParsedWithEdits?.edit(edit);
-        }
-        this._editVersion = version;
-    }
-    async _parseAndUpdateTree(model, version) {
-        const tree = await this._parse(model);
-        if (tree) {
-            this._tree?.delete();
-            this._tree = tree;
-            this._lastFullyParsed?.delete();
-            this._lastFullyParsed = tree.copy();
-            this._lastFullyParsedWithEdits?.delete();
-            this._lastFullyParsedWithEdits = tree.copy();
-            this._versionId = version;
-            return tree;
-        }
-        else if (!this._tree) {
-            this.parser.reset();
-        }
-        return undefined;
-    }
-    _parse(model) {
-        let parseType = TelemetryParseType.Full;
-        if (this.tree) {
-            parseType = TelemetryParseType.Incremental;
-        }
-        return this._parseAndYield(model, parseType);
-    }
-    async _parseAndYield(model, parseType) {
-        const language = model.getLanguageId();
-        let time = 0;
-        let passes = 0;
-        const inProgressVersion = this._editVersion;
-        let newTree;
-        this._lastYieldTime = performance.now();
-        do {
-            const timer = performance.now();
-            try {
-                newTree = this.parser.parse((index, position) => this._parseCallback(model, index), this._tree, { progressCallback: this._parseProgressCallback.bind(this) });
-            }
-            catch (e) {
-            }
-            finally {
-                time += performance.now() - timer;
-                passes++;
-            }
-            await ( new Promise(resolve => setTimeout0(resolve)));
-        } while (!model.isDisposed() && !this.isDisposed && !newTree && inProgressVersion === model.getVersionId());
-        this.sendParseTimeTelemetry(parseType, language, time, passes);
-        return (newTree && (inProgressVersion === model.getVersionId())) ? newTree : undefined;
-    }
-    _parseProgressCallback(state) {
-        const now = performance.now();
-        if (now - this._lastYieldTime > 50) {
-            this._lastYieldTime = now;
-            return true;
-        }
-        return false;
-    }
-    _parseCallback(textModel, index) {
-        try {
-            return textModel.getTextBuffer().getNearestChunk(index);
-        }
-        catch (e) {
-            this._logService.debug('Error getting chunk for tree-sitter parsing', e);
-        }
-        return undefined;
-    }
-    sendParseTimeTelemetry(parseType, languageId, time, passes) {
-        this._logService.debug(`Tree parsing (${parseType}) took ${time} ms and ${passes} passes.`);
-        if (parseType === TelemetryParseType.Full) {
-            this._telemetryService.publicLog2(`treeSitter.fullParse`, { languageId, time, passes });
-        }
-        else {
-            this._telemetryService.publicLog2(`treeSitter.incrementalParse`, { languageId, time, passes });
-        }
-    }
-}
-class TreeSitterLanguages extends Disposable {
-    constructor(_treeSitterImporter, _fileService, _environmentService, _registeredLanguages) {
-        super();
-        this._treeSitterImporter = _treeSitterImporter;
-        this._fileService = _fileService;
-        this._environmentService = _environmentService;
-        this._registeredLanguages = _registeredLanguages;
-        this._languages = ( new AsyncCache());
-        this._onDidAddLanguage = this._register(( new Emitter()));
-        this.onDidAddLanguage = this._onDidAddLanguage.event;
-    }
-    getOrInitLanguage(languageId) {
-        if (this._languages.isCached(languageId)) {
-            return this._languages.getSyncIfCached(languageId);
-        }
-        else {
-            this._addLanguage(languageId);
-            return undefined;
-        }
-    }
-    async getLanguage(languageId) {
-        if (this._languages.isCached(languageId)) {
-            return this._languages.getSyncIfCached(languageId);
-        }
-        else {
-            await this._addLanguage(languageId);
-            return this._languages.get(languageId);
-        }
-    }
-    async _addLanguage(languageId) {
-        const languagePromise = this._languages.get(languageId);
-        if (!languagePromise) {
-            this._languages.set(languageId, this._fetchLanguage(languageId));
-            const language = await this._languages.get(languageId);
-            if (!language) {
-                return undefined;
-            }
-            this._onDidAddLanguage.fire({ id: languageId, language });
-        }
-    }
-    async _fetchLanguage(languageId) {
-        const grammarName = this._registeredLanguages.get(languageId);
-        const languageLocation = this._getLanguageLocation(languageId);
-        if (!grammarName || !languageLocation) {
-            return undefined;
-        }
-        const wasmPath = `${languageLocation}/${grammarName}.wasm`;
-        const languageFile = await (this._fileService.readFile(( FileAccess.asFileUri(wasmPath))));
-        const Language = await this._treeSitterImporter.getLanguageClass();
-        return Language.load(languageFile.value.buffer);
-    }
-    _getLanguageLocation(languageId) {
-        const grammarName = this._registeredLanguages.get(languageId);
-        if (!grammarName) {
-            return undefined;
-        }
-        return getModuleLocation();
-    }
-}
 let TreeSitterTextModelService = class TreeSitterTextModelService extends Disposable {
-    constructor(_modelService, fileService, _telemetryService, _logService, _configurationService, _environmentService, _treeSitterImporter) {
+    constructor(_modelService, fileService, _configurationService, _environmentService, _treeSitterImporter, _instantiationService) {
         super();
         this._modelService = _modelService;
-        this._telemetryService = _telemetryService;
-        this._logService = _logService;
         this._configurationService = _configurationService;
         this._environmentService = _environmentService;
         this._treeSitterImporter = _treeSitterImporter;
+        this._instantiationService = _instantiationService;
         this._textModelTreeSitters = this._register(( new DisposableMap()));
         this._registeredLanguages = ( new Map());
         this._onDidUpdateTree = this._register(( new Emitter()));
@@ -515,7 +48,7 @@ let TreeSitterTextModelService = class TreeSitterTextModelService extends Dispos
     }
     getParseResult(textModel) {
         const textModelTreeSitter = this._textModelTreeSitters.get(textModel);
-        return textModelTreeSitter?.textModelTreeSitter.parseResult;
+        return textModelTreeSitter?.textModelTreeSitter;
     }
     async getTree(content, languageId) {
         const language = await this.getLanguage(languageId);
@@ -608,17 +141,10 @@ let TreeSitterTextModelService = class TreeSitterTextModelService extends Dispos
         return this._createTextModelTreeSitter(model, parseImmediately);
     }
     _createTextModelTreeSitter(model, parseImmediately = true) {
-        const textModelTreeSitter = ( new TextModelTreeSitter(
-            model,
-            this._treeSitterLanguages,
-            this._treeSitterImporter,
-            this._logService,
-            this._telemetryService,
-            parseImmediately
-        ));
+        const textModelTreeSitter = this._instantiationService.createInstance(TextModelTreeSitter, model, this._treeSitterLanguages, parseImmediately);
         const disposables = ( new DisposableStore());
         disposables.add(textModelTreeSitter);
-        disposables.add(textModelTreeSitter.onDidChangeParseResult(change => this._onDidUpdateTree.fire({ textModel: model, ranges: change.ranges ?? [], versionId: change.versionId })));
+        disposables.add(textModelTreeSitter.onDidChangeParseResult((e) => this._handleOnDidChangeParseResult(e, model)));
         this._textModelTreeSitters.set(model, {
             textModelTreeSitter,
             disposables,
@@ -626,6 +152,9 @@ let TreeSitterTextModelService = class TreeSitterTextModelService extends Dispos
         });
         return textModelTreeSitter;
     }
+    _handleOnDidChangeParseResult(change, model) {
+        this._onDidUpdateTree.fire({ textModel: model, ranges: change.ranges, versionId: change.versionId, tree: change.tree, languageId: change.languageId, hasInjections: change.hasInjections });
+    }
     _addGrammar(languageId, grammarName) {
         if (!( this._registeredLanguages.has(languageId))) {
             this._registeredLanguages.set(languageId, grammarName);
@@ -633,48 +162,17 @@ let TreeSitterTextModelService = class TreeSitterTextModelService extends Dispos
     }
     _removeGrammar(languageId) {
         if (( this._registeredLanguages.has(languageId))) {
-            this._registeredLanguages.delete('typescript');
+            this._registeredLanguages.delete(languageId);
         }
     }
 };
 TreeSitterTextModelService = ( __decorate([
     ( __param(0, IModelService)),
     ( __param(1, IFileService)),
-    ( __param(2, ITelemetryService)),
-    ( __param(3, ILogService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IEnvironmentService)),
-    ( __param(6, ITreeSitterImporter))
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IEnvironmentService)),
+    ( __param(4, ITreeSitterImporter)),
+    ( __param(5, IInstantiationService))
 ], TreeSitterTextModelService));
-class PromiseWithSyncAccess {
-    get result() {
-        return this._result;
-    }
-    constructor(promise) {
-        this.promise = promise;
-        promise.then(result => {
-            this._result = ( new PromiseResult(result, undefined));
-        }).catch(e => {
-            this._result = ( new PromiseResult(undefined, e));
-        });
-    }
-}
-class AsyncCache {
-    constructor() {
-        this._values = ( new Map());
-    }
-    set(key, promise) {
-        this._values.set(key, ( new PromiseWithSyncAccess(promise)));
-    }
-    get(key) {
-        return this._values.get(key)?.promise;
-    }
-    getSyncIfCached(key) {
-        return this._values.get(key)?.result?.data;
-    }
-    isCached(key) {
-        return this._values.get(key)?.result !== undefined;
-    }
-}
 
-export { TextModelTreeSitter, TreeSitterLanguages, TreeSitterParseResult, TreeSitterTextModelService };
+export { TreeSitterTextModelService };

package/vscode/src/vs/editor/common/services/treeSitterParserService.d.ts

@@ -1,6 +1,7 @@
 import type * as Parser from "@vscode/tree-sitter-wasm";
 import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
 import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { IModelContentChangedEvent } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEvents";
 import { ITreeSitterImporter } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitterParserService.service";
 export declare const EDITOR_EXPERIMENTAL_PREFER_TREESITTER = "editor.experimental.preferTreeSitter";
 export declare const TREESITTER_ALLOWED_SUPPORT: string[];
@@ -11,26 +12,38 @@ export interface RangeWithOffsets {
 }
 export interface RangeChange {
     newRange: Range;
-    oldRangeLength: number;
     newRangeStartOffset: number;
     newRangeEndOffset: number;
 }
 export interface TreeParseUpdateEvent {
     ranges: RangeChange[] | undefined;
+    language: string;
     versionId: number;
+    tree: Parser.Tree;
+    includedModelChanges: IModelContentChangedEvent[];
 }
-export interface TreeUpdateEvent {
-    textModel: ITextModel;
+export interface ModelTreeUpdateEvent {
     ranges: RangeChange[];
     versionId: number;
+    tree: ITextModelTreeSitter;
+    languageId: string;
+    hasInjections: boolean;
+}
+export interface TreeUpdateEvent extends ModelTreeUpdateEvent {
+    textModel: ITextModel;
 }
 export interface ITreeSitterParseResult {
     readonly tree: Parser.Tree | undefined;
     readonly language: Parser.Language;
+    readonly languageId: string;
+    readonly ranges: Parser.Range[] | undefined;
     versionId: number;
 }
 export interface ITextModelTreeSitter {
     parse(languageId?: string): Promise<ITreeSitterParseResult | undefined>;
+    textModel: ITextModel;
+    parseResult: ITreeSitterParseResult | undefined;
+    getInjection(offset: number, parentLanguage: string): ITreeSitterParseResult | undefined;
     dispose(): void;
 }
 export declare class TreeSitterImporter implements ITreeSitterImporter {

package/vscode/src/vs/editor/common/services/treeSitterParserService.js

@@ -1,7 +1,7 @@
 
 
 const EDITOR_EXPERIMENTAL_PREFER_TREESITTER = 'editor.experimental.preferTreeSitter';
-const TREESITTER_ALLOWED_SUPPORT = ['typescript', 'ini'];
+const TREESITTER_ALLOWED_SUPPORT = ['css', 'typescript', 'ini', 'regex'];
 class TreeSitterImporter {
     constructor() { }
     async _getTreeSitterImport() {

package/vscode/src/vs/workbench/services/treeSitter/browser/treeSitterCodeEditors.d.ts

@@ -13,15 +13,20 @@ export declare class TreeSitterCodeEditors extends Disposable {
     private readonly _languageId;
     private readonly _codeEditorService;
     private readonly _treeSitterParserService;
-    private readonly _editors;
+    private readonly _textModels;
+    private readonly _languageEditors;
+    private readonly _allEditors;
     private readonly _onDidChangeViewport;
     readonly onDidChangeViewport: Event<IViewPortChangeEvent>;
     constructor(_languageId: string, _codeEditorService: ICodeEditorService, _treeSitterParserService: ITreeSitterParserService);
-    get editors(): ICodeEditor[];
+    get textModels(): ITextModel[];
+    getEditorForModel(model: ITextModel): ICodeEditor | undefined;
     getInitialViewPorts(): Promise<IViewPortChangeEvent[]>;
     private _onCodeEditorRemove;
     private getEditorModel;
     private _onCodeEditorAdd;
+    private _tryAddEditor;
+    private _onDidChangeModel;
     private _onViewportChange;
     private _nonIntersectingViewPortRanges;
 }