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

package/vscode/src/vs/editor/common/services/treeSitter/treeSitterLanguages.d.ts

@@ -0,0 +1,30 @@
+import type * as Parser from "@vscode/tree-sitter-wasm";
+import { AppResourcePath } from "@codingame/monaco-vscode-api/vscode/vs/base/common/network";
+import { ITreeSitterImporter } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitterParserService.service";
+import { Disposable } 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 { Emitter, Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service";
+export declare const MODULE_LOCATION_SUBPATH = "@vscode/tree-sitter-wasm/wasm";
+export declare function getModuleLocation(environmentService: IEnvironmentService): AppResourcePath;
+export declare class TreeSitterLanguages extends Disposable {
+    private readonly _treeSitterImporter;
+    private readonly _fileService;
+    private readonly _environmentService;
+    private readonly _registeredLanguages;
+    private _languages;
+    readonly _onDidAddLanguage: Emitter<{
+        id: string;
+        language: Parser.Language;
+    }>;
+    readonly onDidAddLanguage: Event<{
+        id: string;
+        language: Parser.Language;
+    }>;
+    constructor(_treeSitterImporter: ITreeSitterImporter, _fileService: IFileService, _environmentService: IEnvironmentService, _registeredLanguages: Map<string, string>);
+    getOrInitLanguage(languageId: string): Parser.Language | undefined;
+    getLanguage(languageId: string): Promise<Parser.Language | undefined>;
+    private _addLanguage;
+    private _fetchLanguage;
+    private _getLanguageLocation;
+}

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

@@ -0,0 +1,102 @@
+
+import { nodeModulesPath, FileAccess } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { PromiseResult } from '@codingame/monaco-vscode-ae8a8ca1-f243-508b-9c37-c88ebbd295fa-common/vscode/vs/base/common/observableInternal/promise';
+
+const MODULE_LOCATION_SUBPATH = `@vscode/tree-sitter-wasm/wasm`;
+function getModuleLocation(environmentService) {
+    return `${nodeModulesPath}/${MODULE_LOCATION_SUBPATH}`;
+}
+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();
+    }
+}
+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;
+    }
+}
+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));
+        });
+    }
+}
+
+export { MODULE_LOCATION_SUBPATH, TreeSitterLanguages, getModuleLocation };

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

@@ -1,94 +1,21 @@
 import type * as Parser from "@vscode/tree-sitter-wasm";
-import { ITreeSitterParseResult, ITextModelTreeSitter, TreeUpdateEvent, TreeParseUpdateEvent } from "../treeSitterParserService.js";
+import { ITextModelTreeSitter, TreeUpdateEvent } from "../treeSitterParserService.js";
 import { ITreeSitterImporter } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitterParserService.service";
 import { ITreeSitterParserService } 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, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
 import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
-import { IModelContentChangedEvent } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEvents";
-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 { Emitter, Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service";
-export declare class TextModelTreeSitter extends Disposable implements ITextModelTreeSitter {
-    readonly model: ITextModel;
-    private readonly _treeSitterLanguages;
-    private readonly _treeSitterImporter;
-    private readonly _logService;
-    private readonly _telemetryService;
-    private _onDidChangeParseResult;
-    readonly onDidChangeParseResult: Event<TreeParseUpdateEvent>;
-    private _parseResult;
-    private _versionId;
-    get parseResult(): ITreeSitterParseResult | undefined;
-    constructor(model: ITextModel, _treeSitterLanguages: TreeSitterLanguages, _treeSitterImporter: ITreeSitterImporter, _logService: ILogService, _telemetryService: ITelemetryService, parseImmediately?: boolean);
-    private readonly _parseSessionDisposables;
-    private _onDidChangeLanguage;
-    parse(languageId?: string): Promise<ITreeSitterParseResult | undefined>;
-    private _getLanguage;
-    private _onDidChangeContent;
-}
-export declare class TreeSitterParseResult implements IDisposable, ITreeSitterParseResult {
-    readonly parser: Parser.Parser;
-    readonly language: Parser.Language;
-    private readonly _logService;
-    private readonly _telemetryService;
-    private _tree;
-    private _lastFullyParsed;
-    private _lastFullyParsedWithEdits;
-    private readonly _onDidUpdate;
-    readonly onDidUpdate: Event<TreeParseUpdateEvent>;
-    private _versionId;
-    private _editVersion;
-    get versionId(): number;
-    private _isDisposed;
-    constructor(parser: Parser.Parser, language: Parser.Language, _logService: ILogService, _telemetryService: ITelemetryService);
-    dispose(): void;
-    get tree(): Parser.Tree | undefined;
-    get isDisposed(): boolean;
-    private findChangedNodes;
-    private calculateRangeChange;
-    private _onDidChangeContentQueue;
-    onDidChangeContent(model: ITextModel, changes: IModelContentChangedEvent | undefined): void;
-    private _applyEdits;
-    private _parseAndUpdateTree;
-    private _parse;
-    private _parseAndYield;
-    private _lastYieldTime;
-    private _parseProgressCallback;
-    private _parseCallback;
-    private sendParseTimeTelemetry;
-}
-export declare class TreeSitterLanguages extends Disposable {
-    private readonly _treeSitterImporter;
-    private readonly _fileService;
-    private readonly _environmentService;
-    private readonly _registeredLanguages;
-    private _languages;
-    readonly _onDidAddLanguage: Emitter<{
-        id: string;
-        language: Parser.Language;
-    }>;
-    readonly onDidAddLanguage: Event<{
-        id: string;
-        language: Parser.Language;
-    }>;
-    constructor(_treeSitterImporter: ITreeSitterImporter, _fileService: IFileService, _environmentService: IEnvironmentService, _registeredLanguages: Map<string, string>);
-    getOrInitLanguage(languageId: string): Parser.Language | undefined;
-    getLanguage(languageId: string): Promise<Parser.Language | undefined>;
-    private _addLanguage;
-    private _fetchLanguage;
-    private _getLanguageLocation;
-}
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 export declare class TreeSitterTextModelService extends Disposable implements ITreeSitterParserService {
     private readonly _modelService;
-    private readonly _telemetryService;
-    private readonly _logService;
     private readonly _configurationService;
     private readonly _environmentService;
     private readonly _treeSitterImporter;
+    private readonly _instantiationService;
     readonly _serviceBrand: undefined;
     private _init;
     private _textModelTreeSitters;
@@ -101,9 +28,9 @@ export declare class TreeSitterTextModelService extends Disposable implements IT
     private _onDidUpdateTree;
     readonly onDidUpdateTree: Event<TreeUpdateEvent>;
     isTest: boolean;
-    constructor(_modelService: IModelService, fileService: IFileService, _telemetryService: ITelemetryService, _logService: ILogService, _configurationService: IConfigurationService, _environmentService: IEnvironmentService, _treeSitterImporter: ITreeSitterImporter);
+    constructor(_modelService: IModelService, fileService: IFileService, _configurationService: IConfigurationService, _environmentService: IEnvironmentService, _treeSitterImporter: ITreeSitterImporter, _instantiationService: IInstantiationService);
     getOrInitLanguage(languageId: string): Parser.Language | undefined;
-    getParseResult(textModel: ITextModel): ITreeSitterParseResult | undefined;
+    getParseResult(textModel: ITextModel): ITextModelTreeSitter | undefined;
     getTree(content: string, languageId: string): Promise<Parser.Tree | undefined>;
     getTreeSync(content: string, languageId: string): Parser.Tree | undefined;
     getLanguage(languageId: string): Promise<Parser.Language | undefined>;
@@ -115,6 +42,7 @@ export declare class TreeSitterTextModelService extends Disposable implements IT
     private _registerModelServiceListeners;
     getTextModelTreeSitter(model: ITextModel, parseImmediately?: boolean): Promise<ITextModelTreeSitter>;
     private _createTextModelTreeSitter;
+    private _handleOnDidChangeParseResult;
     private _addGrammar;
     private _removeGrammar;
 }