@spyglassmc/language-server 0.4.54 → 0.4.56

package/lib/server.js

@@ -9,6 +9,7 @@ import url from 'url';
 import * as util from 'util';
 import * as ls from 'vscode-languageserver/node.js';
 import { toCore, toLS } from './util/index.js';
+import { LspFileWatcher } from './util/LspFileWatcher.js';
 export * from './util/types.js';
 if (process.argv.length === 2) {
     // When the server is launched from the cmd script, the process arguments
@@ -21,6 +22,7 @@ const cacheRoot = fileUtil.ensureEndingSlash(url.pathToFileURL(cacheRootPath).to
 const connection = ls.createConnection();
 let capabilities;
 let workspaceFolders;
+let projectRoots;
 let hasShutdown = false;
 const externals = getNodeJsExternals({ cacheRoot });
 const logger = {
@@ -30,9 +32,17 @@ const logger = {
     warn: (msg, ...args) => connection.console.warn(util.format(msg, ...args)),
 };
 let service;
-function buildSemanticTokensCapability() {
+function buildSemanticTokensCapability(isDynamic) {
+    // Always register everything for static registration, so all changes to the config can be
+    // processed by the request handlers instead
+    const semanticTokensConfig = service.project.config.env.feature.semanticColoring;
+    let disabledLanguages = [];
+    if (isDynamic && typeof semanticTokensConfig === 'object'
+        && Array.isArray(semanticTokensConfig.disabledLanguages)) {
+        disabledLanguages = semanticTokensConfig.disabledLanguages;
+    }
     return {
-        documentSelector: toLS.documentSelector(service.project.meta),
+        documentSelector: toLS.documentSelector(service.project.meta, { disabledLanguages }),
         legend: toLS.semanticTokensLegend(),
         full: { delta: false },
         range: true,
@@ -45,6 +55,7 @@ connection.onInitialize(async (params) => {
     logger.info(`[onInitialize] initializationOptions = ${JSON.stringify(initializationOptions)}`);
     capabilities = params.capabilities;
     workspaceFolders = params.workspaceFolders ?? [];
+    projectRoots = workspaceFolders.map(f => core.fileUtil.ensureEndingSlash(f.uri));
     if (initializationOptions?.inDevelopmentMode) {
         await new Promise((resolve) => setTimeout(resolve, 3000));
         logger.warn('Delayed 3 seconds manually. If you see this in production, it means SPGoding messed up.');
@@ -67,13 +78,11 @@ connection.onInitialize(async (params) => {
                 'project#ready#bind',
             ]),
             project: {
-                defaultConfig: core.ConfigService.merge(core.VanillaConfig, {
-                    env: { gameVersion: initializationOptions?.gameVersion },
-                }),
+                defaultConfig: core.ConfigService.merge(core.VanillaConfig, initializationOptions?.defaultConfig ?? {}),
                 cacheRoot,
                 externals,
                 initializers: [mcdoc.initialize, je.initialize],
-                projectRoots: workspaceFolders.map(f => core.fileUtil.ensureEndingSlash(f.uri)),
+                projectRoots,
             },
         });
         service.project.on('documentErrored', async ({ errors, uri, version }) => {
@@ -101,7 +110,7 @@ connection.onInitialize(async (params) => {
     let semanticTokensProvider = undefined;
     if (!capabilities.textDocument?.semanticTokens?.dynamicRegistration) {
         logger.info("[startDynamicSemanticTokensRegistration] LanguageClient didn't permit dynamic registration for semantic tokens. Registering semantic tokens statically instead...");
-        semanticTokensProvider = buildSemanticTokensCapability();
+        semanticTokensProvider = buildSemanticTokensCapability(false);
     }
     const customCapabilities = {
         dataHackPubify: true,
@@ -141,8 +150,47 @@ connection.onInitialized(async () => {
     if (capabilities.textDocument?.formatting?.dynamicRegistration) {
         void connection.client.register(ls.DocumentFormattingRequest.type, { documentSelector: [{ language: 'mcdoc' }] });
     }
+    if (capabilities.workspace?.didChangeConfiguration?.dynamicRegistration) {
+        void connection.client.register(ls.DidChangeConfigurationNotification.type, { section: ['spyglassmc'] });
+    }
+    // In case the initializationOptions were incomplete (for example because the client doesn't support them)
+    await updateEditorConfiguration();
     startDynamicSemanticTokensRegistration();
-    await service.project.ready();
+    // Initializes LspFileWatcher only when client supports didChangeWatchedFiles notifications.
+    const fileWatcher = capabilities.workspace?.didChangeWatchedFiles?.dynamicRegistration
+        ? new LspFileWatcher({
+            capabilities,
+            connection,
+            externals,
+            locations: projectRoots,
+            logger,
+            predicate: (uri) => !service.project.shouldExclude(uri),
+        })
+            .on('ready', () => logger.info('[FileWatcher] ready'))
+            .on('add', (uri) => logger.info('[FileWatcher] added', uri))
+            .on('change', (uri) => logger.info('[FileWatcher] changed', uri))
+            .on('unlink', (uri) => logger.info('[FileWatcher] unlinked', uri))
+            .on('error', (e) => logger.error('[FileWatcher]', e))
+        : undefined;
+    if (fileWatcher) {
+        // Listen for config changes and reconcile the internal state of the file watcher if
+        // `env.exclude` has changed.
+        service.project.on('configChanged', async ({ oldConfig, newConfig }) => {
+            const oldExclude = new Set(oldConfig.env.exclude);
+            const newExclude = new Set(newConfig.env.exclude);
+            if (oldExclude.size === newExclude.size && oldExclude.isSubsetOf(newExclude)) {
+                // `env.exclude` has not changed. Skip.
+                return;
+            }
+            logger.info('[FileWatcher] env.exclude config has changed. Reconciling...');
+            for (const root of projectRoots) {
+                await fileWatcher.reconcile(root);
+            }
+        });
+    }
+    await service.project.ready({
+        projectRootsWatcher: fileWatcher,
+    });
     if (capabilities.workspace?.workspaceFolders) {
         connection.workspace.onDidChangeWorkspaceFolders(async () => {
             // FIXME
@@ -164,7 +212,7 @@ function startDynamicSemanticTokensRegistration() {
             return;
         }
         logger.info('[registerDynamicSemanticTokens] Registering dynamic semantic tokens');
-        dynamicSemanticTokensDiposable = connection.client.register(ls.SemanticTokensRegistrationType.type, buildSemanticTokensCapability());
+        dynamicSemanticTokensDiposable = connection.client.register(ls.SemanticTokensRegistrationType.type, buildSemanticTokensCapability(true));
     }
     function unregisterDynamicSemanticTokens() {
         logger.info('[unregisterDynamicSemanticTokens] Unregistering dynamic semantic tokens');
@@ -174,13 +222,39 @@ function startDynamicSemanticTokensRegistration() {
     if (service.project.config.env.feature.semanticColoring) {
         registerDynamicSemanticTokens();
     }
-    service.project.on('configChanged', config => {
-        if (config.env.feature.semanticColoring) {
-            registerDynamicSemanticTokens();
+    function didConfigChange(oldSemanticTokensConfig, newSemanticTokensConfig) {
+        if (oldSemanticTokensConfig === newSemanticTokensConfig) {
+            return false;
         }
-        else {
+        if (typeof oldSemanticTokensConfig !== 'object'
+            || typeof newSemanticTokensConfig !== 'object') {
+            return true;
+        }
+        if (!oldSemanticTokensConfig.disabledLanguages
+            && !newSemanticTokensConfig.disabledLanguages) {
+            return false;
+        }
+        if (Array.isArray(oldSemanticTokensConfig.disabledLanguages)
+            && Array.isArray(newSemanticTokensConfig.disabledLanguages)
+            && oldSemanticTokensConfig.disabledLanguages.length
+                === newSemanticTokensConfig.disabledLanguages.length
+            && oldSemanticTokensConfig.disabledLanguages.every((language, index) => language === newSemanticTokensConfig.disabledLanguages[index])) {
+            return false;
+        }
+        return true;
+    }
+    service.project.on('configChanged', ({ oldConfig, newConfig }) => {
+        const oldSemanticTokensConfig = oldConfig.env.feature.semanticColoring;
+        const newSemanticTokensConfig = newConfig.env.feature.semanticColoring;
+        if (!didConfigChange(oldSemanticTokensConfig, newSemanticTokensConfig)) {
+            return;
+        }
+        if (oldSemanticTokensConfig) {
             unregisterDynamicSemanticTokens();
         }
+        if (newSemanticTokensConfig) {
+            registerDynamicSemanticTokens();
+        }
     });
 }
 connection.onDidOpenTextDocument(({ textDocument: { text, uri, version, languageId: languageID } }) => {
@@ -192,7 +266,6 @@ connection.onDidChangeTextDocument(({ contentChanges, textDocument: { uri, versi
 connection.onDidCloseTextDocument(({ textDocument: { uri } }) => {
     service.project.onDidClose(uri);
 });
-connection.workspace.onDidRenameFiles(({}) => { });
 connection.onCodeAction(async ({ textDocument: { uri }, range }) => {
     const docAndNode = await service.project.ensureClientManagedChecked(uri);
     if (!docAndNode || !service.project.config.env.feature.codeActions) {
@@ -378,6 +451,12 @@ connection.onDocumentFormatting(async ({ textDocument: { uri }, options }) => {
     }
     return [toLS.textEdit(node.range, text, doc)];
 });
+connection.onDidChangeConfiguration(updateEditorConfiguration);
+async function updateEditorConfiguration() {
+    const settings = await connection.workspace.getConfiguration({ section: 'spyglassmc' });
+    const config = core.PartialConfig.buildConfigFromEditorSettingsSafe(settings);
+    await service.project.onEditorConfigurationUpdate(config);
+}
 connection.onShutdown(async () => {
     await service.project.close();
     hasShutdown = true;

package/lib/util/LspFileWatcher.d.ts

@@ -0,0 +1,33 @@
+import * as core from '@spyglassmc/core';
+import EventEmitter from 'events';
+import * as ls from 'vscode-languageserver/node.js';
+type Predicate = (uri: string) => boolean;
+export interface LspFileWatcherOptions {
+    capabilities: ls.ClientCapabilities;
+    connection: ls.Connection;
+    externals: core.Externals;
+    locations: readonly core.FsLocation[];
+    logger: core.Logger;
+    predicate: Predicate;
+}
+/**
+ * A file watcher based on Language Server Protocol's `workspace/didChangeWatchedFiles`
+ * notification.
+ */
+export declare class LspFileWatcher extends EventEmitter implements core.FileWatcher {
+    #private;
+    get watchedFiles(): core.UriStore;
+    constructor({ capabilities, connection, externals, locations, logger, predicate }: LspFileWatcherOptions);
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Reconcile the internal URI store with the actual directories and files on the disk.
+     * @param uri URI that should be reconciled. If it's a file URI, ensure the file exists in the
+     * internal URI store; if it's a directory URI, ensure all contents of it exists and no extra
+     * content is recorded; if the URI does not exist, reconcile its parent URI up until the watched
+     * `locations`.
+     */
+    reconcile(uri: core.FsLocation): Promise<void>;
+}
+export {};
+//# sourceMappingURL=LspFileWatcher.d.ts.map

package/lib/util/LspFileWatcher.js

@@ -0,0 +1,226 @@
+import * as core from '@spyglassmc/core';
+import EventEmitter from 'events';
+import * as ls from 'vscode-languageserver/node.js';
+/**
+ * A file watcher based on Language Server Protocol's `workspace/didChangeWatchedFiles`
+ * notification.
+ */
+export class LspFileWatcher extends EventEmitter {
+    #ready = false;
+    #connection;
+    #externals;
+    #locations;
+    #logger;
+    #predicate;
+    #watchedFiles = new core.UriStore();
+    #lspDisposables = [];
+    get watchedFiles() {
+        return this.#watchedFiles;
+    }
+    constructor({ capabilities, connection, externals, locations, logger, predicate }) {
+        super();
+        this.#connection = connection;
+        this.#externals = externals;
+        this.#locations = locations.map((uri) => core.normalizeUri(uri.toString()));
+        this.#logger = logger;
+        this.#predicate = predicate;
+        if (!capabilities.workspace?.didChangeWatchedFiles?.dynamicRegistration) {
+            throw new Error('LspFileWatcher requires dynamic registration capability for didChangeWatchedFiles notifications');
+        }
+    }
+    async ready() {
+        try {
+            this.#lspDisposables = [
+                this.#connection.onDidChangeWatchedFiles((params) => {
+                    this.#logger.info('[LspFileWatcher] raw LSP changes', JSON.stringify(params));
+                    return this.#onLspDidChangeWatchedFiles(params);
+                }),
+                await this.#connection.client.register(ls.DidChangeWatchedFilesNotification.type, {
+                    // "**/*" is needed to watch changes to folders as well.
+                    // https://github.com/microsoft/vscode/issues/60813#issuecomment-1145821690
+                    watchers: [{ globPattern: '**/*' }],
+                }),
+            ];
+            for (const location of this.#locations) {
+                for (const uri of await core.fileUtil.getAllFiles(this.#externals, location)) {
+                    if (this.#predicate(uri)) {
+                        this.#watchedFiles.add(uri);
+                    }
+                }
+            }
+            this.#ready = true;
+            this.emit('ready');
+        }
+        catch (e) {
+            this.emit('error', e);
+        }
+    }
+    async close() {
+        for (const disposable of this.#lspDisposables) {
+            disposable.dispose();
+        }
+        this.#lspDisposables = [];
+    }
+    async #onLspDidChangeWatchedFiles({ changes }) {
+        if (!this.#ready) {
+            throw new Error('Callback #onLspDidChangeWatchedFiles executed before ready');
+        }
+        for (const { type, uri } of changes) {
+            try {
+                const normalizedUri = core.normalizeUri(uri);
+                switch (type) {
+                    case ls.FileChangeType.Created: {
+                        await this.#handleAdd(core.fileUtil.trimEndingSlash(normalizedUri));
+                        break;
+                    }
+                    case ls.FileChangeType.Changed:
+                        await this.#handleChange(core.fileUtil.trimEndingSlash(normalizedUri));
+                        break;
+                    case ls.FileChangeType.Deleted: {
+                        this.#handleDelete(core.fileUtil.trimEndingSlash(normalizedUri));
+                        break;
+                    }
+                }
+            }
+            catch (e) {
+                this.#logger.error('[LspFileWatcher] handle error', e);
+            }
+        }
+    }
+    async #handleAdd(uri) {
+        let stat;
+        try {
+            stat = await this.#externals.fs.stat(uri);
+        }
+        catch (e) {
+            if (!this.#externals.error.isKind(e, 'ENOENT')) {
+                throw e;
+            }
+            // LSP gave us a non-existent URI. Reconcile its parent directory just to be safe.
+            this.#logger.warn(`[LspFileWatcher] non-existent URI ${uri}; will reconcile parent directory`);
+            return this.#reconcileParentOf(uri);
+        }
+        if (stat.isDirectory()) {
+            // Find all files under the added URI and send 'add' events for them.
+            for (const fileUri of await core.fileUtil.getAllFiles(this.#externals, uri)) {
+                this.#addIfNeeded(fileUri);
+            }
+        }
+        else if (stat.isFile()) {
+            this.#addIfNeeded(uri);
+        }
+    }
+    async #handleChange(uri) {
+        if (!this.#predicate(uri) || this.#watchedFiles.has(core.fileUtil.ensureEndingSlash(uri))) {
+            // Skip non-predicate matching URIs and directory URIs.
+            return;
+        }
+        if (!this.#watchedFiles.has(uri)) {
+            this.#logger.warn(`[LspFileWatcher] unknown changed URI ${uri}; handling as add instead`);
+            return this.#handleAdd(uri);
+        }
+        this.emit('change', uri);
+    }
+    #handleDelete(uri) {
+        const dirUri = core.fileUtil.ensureEndingSlash(uri);
+        if (this.#watchedFiles.has(uri)) {
+            // Is a file URI. Delete it directly.
+            this.#watchedFiles.delete(uri);
+            this.emit('unlink', uri);
+        }
+        else if (this.#watchedFiles.has(dirUri)) {
+            // Is a directory URI.
+            // Find all files under the deleted URI and send 'unlink' events for them.
+            // getSubFiles() returns an iterator that would return nothing after dirUri
+            // is deleted from #watchedFiles, therefore we need to collect the results of
+            // the iterator before it is deleted.
+            const subFiles = [...this.#watchedFiles.getSubFiles(dirUri)];
+            this.#watchedFiles.delete(dirUri);
+            for (const watchedUri of subFiles) {
+                this.emit('unlink', watchedUri);
+            }
+        }
+    }
+    /**
+     * Add the file URI to the internal store and emit the `add` event if the file hasn't been
+     * excluded by predicate and doesn't already exist in the store.
+     */
+    #addIfNeeded(uri) {
+        if (!this.#watchedFiles.has(uri) && this.#predicate(uri)) {
+            this.#watchedFiles.add(uri);
+            this.emit('add', uri);
+        }
+    }
+    /**
+     * Delete the file URI from the internal store and emit the `unlink` event if the file has been
+     * excluded by predicate but exist in the store.
+     */
+    #deleteIfExcluded(uri) {
+        if (this.#watchedFiles.has(uri) && !this.#predicate(uri)) {
+            this.#watchedFiles.delete(uri);
+            this.emit('unlink', uri);
+        }
+    }
+    /**
+     * Reconcile the internal URI store with the actual directories and files on the disk.
+     * @param uri URI that should be reconciled. If it's a file URI, ensure the file exists in the
+     * internal URI store; if it's a directory URI, ensure all contents of it exists and no extra
+     * content is recorded; if the URI does not exist, reconcile its parent URI up until the watched
+     * `locations`.
+     */
+    async reconcile(uri) {
+        return this.#reconcile(core.normalizeUri(uri.toString()));
+    }
+    async #reconcile(uri, stat) {
+        uri = core.fileUtil.trimEndingSlash(uri);
+        try {
+            stat ??= await this.#externals.fs.stat(uri);
+            if (stat.isDirectory()) {
+                // For directory, reconcile all its entries recursively.
+                const dirUri = core.fileUtil.ensureEndingSlash(uri);
+                const diskEntries = await this.#externals.fs.readdir(dirUri);
+                const diskEntryNames = new Set();
+                for (const diskEntry of diskEntries) {
+                    diskEntryNames.add(diskEntry.name);
+                    await this.#reconcile(core.fileUtil.join(dirUri, diskEntry.name), diskEntry);
+                }
+                // Remove extra entries of this directory, if any, from the internal URI store.
+                const storeEntryNames = this.#watchedFiles.getChildrenNames(dirUri);
+                for (const storeEntryName of storeEntryNames) {
+                    if (!diskEntryNames.has(storeEntryName)) {
+                        this.#handleDelete(core.fileUtil.join(dirUri, storeEntryName));
+                    }
+                }
+            }
+            else if (stat.isFile()) {
+                // For file, ensure it exists in the internal store if it belongs there.
+                this.#addIfNeeded(uri);
+                // And delete it if it should be excluded.
+                this.#deleteIfExcluded(uri);
+            }
+        }
+        catch (e) {
+            if (!this.#externals.error.isKind(e, 'ENOENT')) {
+                throw e;
+            }
+            // The URI does not exist. Remove it from internal store.
+            this.#logger.warn(`[LspFileWatcher] non-existent URI during reconcilation ${uri}; will reconcile with further parent directory`);
+            this.#handleDelete(uri);
+            // It is weird that reconcile() was called on a non-existent URI. We will go up a
+            // directory and reconcile there as well just to fix anything that might be wrong.
+            return this.#reconcileParentOf(uri);
+        }
+    }
+    async #reconcileParentOf(uri) {
+        const parentUri = core.fileUtil.trimEndingSlash(core.fileUtil.getParentOfUri(uri).toString());
+        // We only reconcile the parent if it is different from the current URI (to avoid an infinite
+        // loop) and if it is under the watched locations of the file watcher.
+        if (!(parentUri !== uri
+            && this.#locations.some((loc) => core.fileUtil.isSubUriOf(parentUri, loc.toString())))) {
+            this.#logger.warn(`[LspFileWatcher] reconcilation stopped after ${uri} at ${parentUri}`);
+            return;
+        }
+        return this.reconcile(parentUri);
+    }
+}
+//# sourceMappingURL=LspFileWatcher.js.map

package/lib/util/toLS.d.ts

@@ -10,7 +10,9 @@ export declare function diagnostic(error: core.PosRangeLanguageError): ls.Diagno
 export declare function diagnostics(errors: readonly core.PosRangeLanguageError[]): ls.Diagnostic[];
 export declare function diagnosticSeverity(severity: core.ErrorSeverity): ls.DiagnosticSeverity;
 export declare function documentHighlight(locations: core.SymbolLocations | undefined): ls.DocumentHighlight[] | undefined;
-export declare function documentSelector(meta: core.MetaRegistry): ls.DocumentSelector;
+export declare function documentSelector(meta: core.MetaRegistry, { disabledLanguages }?: {
+    disabledLanguages?: string[];
+}): ls.DocumentSelector;
 export declare function documentSymbol(symbol: core.Symbol, symLoc: core.SymbolLocation, doc: TextDocument, hierarchicalSupport: boolean | undefined, supportedKinds?: ls.SymbolKind[]): ls.DocumentSymbol;
 export declare function documentSymbols(map: core.SymbolMap | undefined, doc: TextDocument, hierarchicalSupport: boolean | undefined, supportedKinds?: ls.SymbolKind[]): ls.DocumentSymbol[];
 export declare function documentSymbolsFromTable(table: core.SymbolTable, doc: TextDocument, hierarchicalSupport: boolean | undefined, supportedKinds?: ls.SymbolKind[]): ls.DocumentSymbol[];

package/lib/util/toLS.js

@@ -65,8 +65,8 @@ export function documentHighlight(locations) {
         range: loc.posRange,
     }));
 }
-export function documentSelector(meta) {
-    const ans = meta.getLanguages().map((id) => ({ language: id }));
+export function documentSelector(meta, { disabledLanguages } = {}) {
+    const ans = meta.getLanguages().filter((id) => disabledLanguages === undefined || !disabledLanguages.includes(id)).map((id) => ({ language: id }));
     return ans;
 }
 export function documentSymbol(symbol, symLoc, doc, hierarchicalSupport, supportedKinds = []) {

package/lib/util/types.d.ts

@@ -1,6 +1,7 @@
+import type { PartialConfig } from '@spyglassmc/core';
 export interface CustomInitializationOptions {
     inDevelopmentMode?: boolean;
-    gameVersion?: string;
+    defaultConfig?: PartialConfig;
 }
 export interface CustomServerCapabilities {
     dataHackPubify?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/language-server",
-  "version": "0.4.54",
+  "version": "0.4.56",
   "type": "module",
   "main": "lib/server.js",
   "types": "lib/server.d.ts",
@@ -35,10 +35,10 @@
     "env-paths": "^2.2.1",
     "vscode-languageserver": "^9.0.1",
     "vscode-languageserver-textdocument": "^1.0.11",
-    "@spyglassmc/core": "0.4.42",
-    "@spyglassmc/java-edition": "0.3.54",
-    "@spyglassmc/locales": "0.3.21",
-    "@spyglassmc/mcdoc": "0.3.46"
+    "@spyglassmc/core": "0.4.44",
+    "@spyglassmc/java-edition": "0.3.56",
+    "@spyglassmc/locales": "0.3.23",
+    "@spyglassmc/mcdoc": "0.3.48"
   },
   "publishConfig": {
     "access": "public"