@knip/language-server 3.1.1 → 3.1.3

package/README.md

@@ -108,7 +108,8 @@ Optionally, the client can implement:
 - Show contention: ambiguous or shadowed exports behind re-exports
 - Show contention: converged (diamond-shaped) re-export paths
 
-Each `File.contention[name].sites` entry describes where contention occurs, its kind, and the originating bindings.
+Each `File.contention[name].sites` entry describes where contention occurs, its
+kind, and the originating bindings.
 
 Example:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knip/language-server",
-  "version": "3.1.1",
+  "version": "3.1.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/webpro-nl/knip.git",
@@ -18,9 +18,9 @@
     "./constants": "./src/constants.js"
   },
   "dependencies": {
-    "vscode-languageserver": "^10.1.1",
-    "vscode-languageserver-textdocument": "^1.0.14",
-    "knip": "^6.36.0"
+    "knip": "^6.44.1",
+    "vscode-languageserver": "^10.1.2",
+    "vscode-languageserver-textdocument": "^1.0.16"
   },
   "engines": {
     "node": "^20.19.0 || >=22.12.0"

package/src/server.js

@@ -99,6 +99,11 @@ export class LanguageServer {
   /** @type {undefined | Session} */
   session;
 
+  revision = 0;
+
+  /** @type {undefined | number} */
+  failedRevision;
+
   /** @type {Rules}  */
   rules = {};
 
@@ -152,8 +157,9 @@ export class LanguageServer {
     });
 
     this.connection.onInitialized(async () => {
+      const revision = this.revision;
       const config = await this.getConfig();
-      if (config?.deferSession !== true) this.start();
+      if (revision === this.revision && config?.deferSession !== true) this.start();
     });
 
     this.connection.onRequest(REQUEST_START, () => this.start());
@@ -244,10 +250,13 @@ export class LanguageServer {
 
   async start() {
     if (this.session) return;
+    const revision = ++this.revision;
 
     try {
       const config = await this.getConfig();
+      if (revision !== this.revision) return;
       const knip = await this.#resolveKnipSession();
+      if (revision !== this.revision) return;
 
       const configFilePath = config?.configFilePath
         ? path.isAbsolute(config.configFilePath)
@@ -257,31 +266,39 @@ export class LanguageServer {
 
       this.connection.console.log('Creating options');
       const options = await knip.createOptions({ cwd: this.cwd, isSession: true, args: { config: configFilePath } });
+      if (revision !== this.revision) return;
       this.rules = options.rules;
 
       this.connection.console.log('Building module graph...');
       const start = Date.now();
       const session = await knip.createSession(options);
+      if (revision !== this.revision) return;
       this.connection.console.log(`Finished building module graph (${Date.now() - start}ms)`);
 
       this.session = session;
       this.publishDiagnostics(this.buildDiagnostics(session.getIssues().issues, config, this.rules));
       this.connection.sendNotification(NOTIFICATION_MODULE_GRAPH_BUILT, { duration: Date.now() - start });
     } catch (_error) {
+      if (revision !== this.revision) return;
+      this.failedRevision = revision;
       this.connection.console.error(`Error: ${_error}`);
     }
   }
 
   stop() {
+    this.revision++;
     this.session = undefined;
     this.fileCache = undefined;
+    this.packageJsonCache = undefined;
+    this.cycleDiagnostics.clear();
+    this.issuesByUri.clear();
     for (const uri of this.published) this.connection.sendDiagnostics({ uri, diagnostics: [] });
     this.published.clear();
   }
 
-  restart() {
+  async restart() {
     this.stop();
-    this.start();
+    await this.start();
   }
 
   getResults() {
@@ -296,7 +313,8 @@ export class LanguageServer {
   async handleFileChanges(params) {
     this.fileCache = undefined;
     this.packageJsonCache = undefined;
-    if (!this.session) return;
+    const session = this.session;
+    if (!session && this.failedRevision !== this.revision) return;
 
     const cwd = this.cwd ?? process.cwd();
 
@@ -312,20 +330,26 @@ export class LanguageServer {
       changes.push({ type, filePath });
     }
 
-    if (changes.length === 0) return;
+    if (!session || changes.length === 0) return;
 
     try {
-      const result = await this.session.handleFileChanges(changes);
+      const result = await session.handleFileChanges(changes);
 
-      if (!result) return;
+      if (!result || this.session !== session) return;
+      this.fileCache = undefined;
+      this.packageJsonCache = undefined;
+      this.cycleDiagnostics.clear();
 
       this.connection.console.log(
         `Module graph updated (${Math.floor(result.duration)}ms • ${(result.mem / 1024 / 1024).toFixed(2)}M)`
       );
 
       const config = await this.getConfig();
-      this.publishDiagnostics(this.buildDiagnostics(this.session.getIssues().issues, config, this.rules));
+      if (this.session !== session) return;
+      this.publishDiagnostics(this.buildDiagnostics(session.getIssues().issues, config, this.rules));
+      this.connection.sendNotification(NOTIFICATION_MODULE_GRAPH_BUILT, { duration: result.duration });
     } catch (_error) {
+      if (this.session !== session) return;
       this.connection.console.error(`Error handling file changes: ${_error}`);
     }
   }

package/test/fixtures/lifecycle.js

@@ -0,0 +1,14 @@
+import { PassThrough } from 'node:stream';
+import {
+  createOptions as options,
+  createSession as session,
+  KNIP_CONFIG_LOCATIONS,
+} from 'knip/session';
+import { CodeActionKind, createConnection as connect } from 'vscode-languageserver/node';
+
+export { CodeActionKind, KNIP_CONFIG_LOCATIONS };
+export const knip = { createOptions: options, createSession: session };
+export const createOptions = options => knip.createOptions(options);
+export const createSession = (...args) => knip.createSession(...args);
+export const connection = connect(new PassThrough(), new PassThrough());
+export const createConnection = () => connection;

package/test/lifecycle.test.js

@@ -0,0 +1,269 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { registerHooks } from 'node:module';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import test, { after } from 'node:test';
+import { pathToFileURL } from 'node:url';
+import { NOTIFICATION_MODULE_GRAPH_BUILT, SESSION_LOADING } from '../src/constants.js';
+import { connection, knip } from './fixtures/lifecycle.js';
+
+const serverUrl = new URL('../src/server.js', import.meta.url).href;
+const fixtureUrl = new URL('./fixtures/lifecycle.js', import.meta.url).href;
+registerHooks({
+  resolve(specifier, context, nextResolve) {
+    if (
+      context.parentURL === serverUrl &&
+      (specifier === 'vscode-languageserver/node' || specifier === 'knip/session')
+    ) {
+      return { url: fixtureUrl, shortCircuit: true };
+    }
+    return nextResolve(specifier, context);
+  },
+});
+
+const { LanguageServer } = await import('../src/server.js');
+const cwd = mkdtempSync(path.join(tmpdir(), 'knip-ls-lifecycle-'));
+after(() => rmSync(cwd, { recursive: true, force: true }));
+const filePath = path.join(cwd, 'value.js');
+const changes = { changes: [{ uri: pathToFileURL(filePath).href, type: 2 }] };
+const changed = file => ({ changes: [{ uri: pathToFileURL(path.join(cwd, file)).href, type: 2 }] });
+const updated = { duration: 1, mem: 1024 };
+const config = { editor: { exports: { quickfix: { enabled: true } } } };
+const options = { rules: { exports: 'warn' } };
+const deferred = () => Promise.withResolvers();
+
+const createSession = (name = 'current') => ({
+  getIssues: () => ({ issues: {} }),
+  getResults: () => ({ name }),
+  describeFile: () => ({ name, metrics: {} }),
+  describePackageJson: () => ({ dependenciesUsage: new Map([[name, { imports: [] }]]) }),
+  handleFileChanges: async () => updated,
+});
+
+const setup = t => {
+  t.mock.method(connection, 'listen', () => {});
+  t.mock.method(connection.workspace, 'getConfiguration', async () => config);
+  t.mock.method(connection.console, 'log', () => {});
+  t.mock.method(connection.console, 'error', () => {});
+  t.mock.method(connection, 'sendDiagnostics', () => {});
+  t.mock.method(connection, 'sendNotification', () => {});
+  t.mock.method(connection, 'onInitialized');
+  t.mock.method(knip, 'createOptions', async () => options);
+  t.mock.method(knip, 'createSession', async () => createSession());
+  const originalConsole = { ...console };
+  const server = new LanguageServer();
+  Object.assign(console, originalConsole);
+  server.cwd = cwd;
+  return server;
+};
+
+test('stop cancels automatic startup while initialization configuration is pending', async t => {
+  const server = setup(t);
+  const pending = deferred();
+  t.mock.method(server, 'getConfig', () => pending.promise);
+  const start = t.mock.method(server, 'start');
+  const initialized = connection.onInitialized.mock.calls[0].arguments[0]();
+  server.stop();
+  pending.resolve(config);
+  await initialized;
+  for (const call of start.mock.calls) await call.result;
+  assert.equal(server.getResults(), null);
+  assert.equal(connection.sendNotification.mock.callCount(), 0);
+});
+
+for (const phase of ['createOptions', 'createSession']) {
+  test(`stop discards a pending ${phase}`, { timeout: 3000 }, async t => {
+    const server = setup(t);
+    const entered = deferred();
+    const pending = deferred();
+    t.mock.method(knip, phase, () => {
+      entered.resolve();
+      return pending.promise;
+    });
+    const start = server.start();
+    await entered.promise;
+    server.stop();
+    pending.resolve(phase === 'createOptions' ? options : createSession('obsolete'));
+    await start;
+    assert.equal(server.getResults(), null);
+    assert.equal(server.getFileDescriptor(filePath), SESSION_LOADING);
+    assert.equal(connection.sendNotification.mock.callCount(), 0);
+    assert.equal(connection.sendDiagnostics.mock.callCount(), 0);
+    if (phase === 'createOptions') assert.equal(knip.createSession.mock.callCount(), 0);
+  });
+
+  test(`restart keeps the new session when obsolete ${phase} finishes last`, { timeout: 3000 }, async t => {
+    const server = setup(t);
+    const entered = deferred();
+    const pending = deferred();
+    let calls = 0;
+    t.mock.method(knip, phase, () => {
+      if (++calls > 1) return phase === 'createOptions' ? options : createSession();
+      entered.resolve();
+      return pending.promise;
+    });
+    const start = server.start();
+    await entered.promise;
+    await server.restart();
+    assert.deepEqual(server.getResults(), { name: 'current' });
+    pending.resolve(phase === 'createOptions' ? { rules: { exports: 'error' } } : createSession('obsolete'));
+    await start;
+    assert.deepEqual(server.getResults(), { name: 'current' });
+    assert.deepEqual(server.rules, options.rules);
+    assert.equal(connection.sendNotification.mock.callCount(), 1);
+  });
+}
+
+test('overlapping starts retain the latest session and ignore obsolete startup errors', { timeout: 3000 }, async t => {
+  const server = setup(t);
+  const entered = deferred();
+  const pending = deferred();
+  let calls = 0;
+  t.mock.method(knip, 'createSession', () => {
+    if (++calls > 1) return createSession();
+    entered.resolve();
+    return pending.promise;
+  });
+  const start = server.start();
+  await entered.promise;
+  await server.start();
+  pending.reject(new Error('obsolete startup failure'));
+  await start;
+  assert.deepEqual(server.getResults(), { name: 'current' });
+  assert.equal(connection.console.error.mock.callCount(), 0);
+  assert.equal(connection.sendNotification.mock.callCount(), 1);
+});
+
+for (const file of ['knip.json', 'package.json']) {
+  test(`${file} change restarts after a failed start`, { timeout: 3000 }, async t => {
+    const server = setup(t);
+    let calls = 0;
+    t.mock.method(knip, 'createOptions', async () => {
+      if (++calls === 1) throw new Error('invalid config');
+      return options;
+    });
+    await server.start();
+    assert.equal(server.getResults(), null);
+    assert.equal(connection.console.error.mock.callCount(), 1);
+    await server.handleFileChanges(changed(file));
+    assert.equal(calls, 2);
+    assert.deepEqual(server.getResults(), { name: 'current' });
+    assert.equal(connection.sendNotification.mock.callCount(), 1);
+  });
+}
+
+test('config change does not start a server stopped after a failed start', { timeout: 3000 }, async t => {
+  const server = setup(t);
+  let calls = 0;
+  t.mock.method(knip, 'createOptions', async () => {
+    calls++;
+    throw new Error('invalid config');
+  });
+  await server.start();
+  server.stop();
+  await server.handleFileChanges(changed('knip.json'));
+  assert.equal(calls, 1);
+  assert.equal(server.getResults(), null);
+  assert.equal(connection.sendNotification.mock.callCount(), 0);
+});
+
+test('source change after a failed start neither restarts nor updates', { timeout: 3000 }, async t => {
+  const server = setup(t);
+  let calls = 0;
+  t.mock.method(knip, 'createOptions', async () => {
+    calls++;
+    throw new Error('invalid config');
+  });
+  await server.start();
+  await server.handleFileChanges(changes);
+  assert.equal(calls, 1);
+  assert.equal(server.getResults(), null);
+  assert.equal(connection.console.error.mock.callCount(), 1);
+});
+
+test('graph updates invalidate descriptors requested during the update and notify without diagnostics', async t => {
+  const server = setup(t);
+  let session = createSession('before');
+  const pending = deferred();
+  server.session = {
+    ...session,
+    describeFile: () => session.describeFile(),
+    describePackageJson: () => session.describePackageJson(),
+    handleFileChanges: () => pending.promise,
+  };
+  const update = server.handleFileChanges(changes);
+  assert.equal(server.getFileDescriptor(filePath).name, 'before');
+  assert.deepEqual(Object.keys(server.getPackageJsonDescriptor().dependenciesUsage), ['before']);
+  session = createSession('after');
+  pending.resolve(updated);
+  await update;
+  assert.equal(server.getFileDescriptor(filePath).name, 'after');
+  assert.deepEqual(Object.keys(server.getPackageJsonDescriptor().dependenciesUsage), ['after']);
+  assert.equal(connection.sendDiagnostics.mock.callCount(), 0);
+  assert.deepEqual(connection.sendNotification.mock.calls[0]?.arguments, [
+    NOTIFICATION_MODULE_GRAPH_BUILT,
+    { duration: updated.duration },
+  ]);
+});
+
+test('stop clears package descriptors before another session starts', async t => {
+  const server = setup(t);
+  server.session = createSession('obsolete');
+  assert.deepEqual(Object.keys(server.getPackageJsonDescriptor().dependenciesUsage), ['obsolete']);
+  server.stop();
+  await server.start();
+  assert.deepEqual(Object.keys(server.getPackageJsonDescriptor().dependenciesUsage), ['current']);
+});
+
+for (const replaced of [false, true]) {
+  for (const phase of ['update', 'configuration']) {
+    test(`discard an obsolete update awaiting ${phase} after ${replaced ? 'replacement' : 'stop'}`, async t => {
+      const server = setup(t);
+      const pending = deferred();
+      const entered = deferred();
+      const old = createSession('obsolete');
+      server.session = old;
+      if (phase === 'update') old.handleFileChanges = () => pending.promise;
+      else {
+        t.mock.method(server, 'getConfig', () => {
+          entered.resolve();
+          return pending.promise;
+        });
+      }
+      const update = server.handleFileChanges(changes);
+      if (phase === 'configuration') await entered.promise;
+      server.stop();
+      if (replaced) {
+        server.session = createSession();
+        server.session.getIssues = () => ({ issues: { files: { [filePath]: { file: { type: 'files', filePath } } } } });
+        server.getFileDescriptor(filePath);
+        server.getPackageJsonDescriptor();
+      }
+      const file = server.fileCache;
+      const manifest = server.packageJsonCache;
+      pending.resolve(phase === 'update' ? updated : config);
+      await update;
+      assert.equal(server.fileCache, file);
+      assert.equal(server.packageJsonCache, manifest);
+      assert.equal(connection.sendDiagnostics.mock.callCount(), 0);
+      assert.equal(connection.sendNotification.mock.callCount(), 0);
+      assert.equal(connection.console.error.mock.callCount(), 0);
+    });
+  }
+}
+
+test('obsolete update errors cannot affect the replacement session', async t => {
+  const server = setup(t);
+  await server.start();
+  const pending = deferred();
+  server.session.handleFileChanges = () => pending.promise;
+  const update = server.handleFileChanges(changes);
+  await server.restart();
+  pending.reject(new Error('obsolete update failure'));
+  await update;
+  assert.deepEqual(server.getResults(), { name: 'current' });
+  assert.deepEqual(server.rules, options.rules);
+  assert.equal(connection.console.error.mock.callCount(), 0);
+  assert.equal(connection.sendNotification.mock.callCount(), 2);
+});

package/test/refresh.test.js

@@ -0,0 +1,114 @@
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { cpSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { NOTIFICATION_MODULE_GRAPH_BUILT, REQUEST_FILE_NODE, REQUEST_RESULTS } from '../src/constants.js';
+
+const startServer = (cwd, t) => {
+  const child = spawn(process.execPath, [fileURLToPath(new URL('../src/cli.js', import.meta.url)), '--stdio'], {
+    cwd,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+  t.after(() => child.kill());
+  let buffer = Buffer.alloc(0);
+  let nextId = 1;
+  const messages = [];
+  const send = payload => {
+    const body = JSON.stringify({ jsonrpc: '2.0', ...payload });
+    child.stdin.write(`Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`);
+  };
+  child.stdout.on('data', chunk => {
+    buffer = Buffer.concat([buffer, chunk]);
+    for (;;) {
+      const header = buffer.indexOf('\r\n\r\n');
+      if (header === -1) return;
+      const length = Number(
+        buffer
+          .subarray(0, header)
+          .toString()
+          .match(/Content-Length: (\d+)/i)?.[1]
+      );
+      if (buffer.length < header + 4 + length) return;
+      const message = JSON.parse(buffer.subarray(header + 4, header + 4 + length).toString());
+      buffer = buffer.subarray(header + 4 + length);
+      if (message.method === 'workspace/configuration') send({ id: message.id, result: [{}] });
+      else messages.push(message);
+    }
+  });
+  const wait = async predicate => {
+    const deadline = Date.now() + 15000;
+    while (Date.now() < deadline) {
+      const index = messages.findIndex(predicate);
+      if (index !== -1) return messages.splice(index, 1)[0];
+      await new Promise(resolve => setTimeout(resolve, 10));
+    }
+    assert.fail(`Timed out waiting for server: ${JSON.stringify(messages)}`);
+  };
+  const request = async (method, params) => {
+    const id = nextId++;
+    send({ id, method, params });
+    const message = await wait(message => message.id === id);
+    assert.equal(message.error, undefined);
+    return message.result;
+  };
+  const initialize = async () => {
+    await request('initialize', {
+      processId: process.pid,
+      capabilities: {},
+      workspaceFolders: [{ uri: pathToFileURL(cwd).href, name: 'lifecycle' }],
+    });
+    send({ method: 'initialized', params: {} });
+    await wait(message => message.method === NOTIFICATION_MODULE_GRAPH_BUILT);
+  };
+  return { child, send, wait, request, initialize };
+};
+
+test('source updates refresh descriptors and notify clients with unchanged empty diagnostics', async t => {
+  const cwd = realpathSync(mkdtempSync(path.join(tmpdir(), 'knip-ls-graph-update-')));
+  t.after(() => rmSync(cwd, { recursive: true, force: true }));
+  writeFileSync(path.join(cwd, 'package.json'), '{"name":"graph-update","type":"module"}');
+  writeFileSync(path.join(cwd, 'knip.json'), '{"entry":["index.js"],"project":["*.js"]}');
+  writeFileSync(path.join(cwd, 'index.js'), "import { used } from './value.js'; console.log(used);");
+  writeFileSync(path.join(cwd, 'value.js'), 'export const used = 1;');
+  const server = startServer(cwd, t);
+  await server.initialize();
+  const uri = pathToFileURL(path.join(cwd, 'value.js')).href;
+  const initial = await server.request(REQUEST_FILE_NODE, { uri });
+  const before = await server.request(REQUEST_RESULTS);
+  for (const issues of Object.values(before.issues)) assert.deepEqual(issues, {});
+  writeFileSync(path.join(cwd, 'value.js'), '\nexport const used = 1;');
+  server.send({ method: 'workspace/didChangeWatchedFiles', params: { changes: [{ uri, type: 2 }] } });
+  await server.wait(message => message.method === NOTIFICATION_MODULE_GRAPH_BUILT);
+  const updated = await server.request(REQUEST_FILE_NODE, { uri });
+  assert.equal(updated.exports[0].line, initial.exports[0].line + 1);
+  assert.deepEqual((await server.request(REQUEST_RESULTS)).issues, before.issues);
+});
+
+test('older local Knip sessions keep the existing manifest reload fallback without exiting the server', async t => {
+  const cwd = realpathSync(mkdtempSync(path.join(tmpdir(), 'knip-ls-legacy-')));
+  t.after(() => rmSync(cwd, { recursive: true, force: true }));
+  cpSync(
+    new URL('../../vscode-knip/test/fixtures/version-bump/knip', import.meta.url),
+    path.join(cwd, 'node_modules/knip'),
+    {
+      recursive: true,
+    }
+  );
+  writeFileSync(path.join(cwd, 'package.json'), '{"name":"legacy","type":"module"}');
+  writeFileSync(path.join(cwd, 'index.js'), '');
+  const server = startServer(cwd, t);
+  await server.initialize();
+  const before = await server.request(REQUEST_RESULTS);
+  assert.ok(before.issues.exports['index.js']['knip-version-1.0.0']);
+  writeFileSync(path.join(cwd, 'package.json'), '{"name":"legacy","type":"module","description":"updated"}');
+  server.send({
+    method: 'workspace/didChangeWatchedFiles',
+    params: { changes: [{ uri: pathToFileURL(path.join(cwd, 'package.json')).href, type: 2 }] },
+  });
+  await server.wait(message => message.method === NOTIFICATION_MODULE_GRAPH_BUILT);
+  assert.deepEqual((await server.request(REQUEST_RESULTS)).issues, before.issues);
+  assert.equal(server.child.exitCode, null);
+});