@knip/language-server 3.0.6 → 3.1.1

package/README.md

@@ -105,8 +105,10 @@ with direct links to their usage locations.
 Optionally, the client can implement:
 
 - Follow cursor between open document and highlight export in view
-- Show contention: naming conflicts through re-exports
-- Show contention: branched/diamond-shaped re-export structures
+- 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.
 
 Example:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knip/language-server",
-  "version": "3.0.6",
+  "version": "3.1.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/webpro-nl/knip.git",
@@ -18,14 +18,15 @@
     "./constants": "./src/constants.js"
   },
   "dependencies": {
-    "vscode-languageserver": "^10.1.0",
-    "vscode-languageserver-textdocument": "^1.0.13",
-    "knip": "^6.32.0"
+    "vscode-languageserver": "^10.1.1",
+    "vscode-languageserver-textdocument": "^1.0.14",
+    "knip": "^6.36.0"
   },
   "engines": {
     "node": "^20.19.0 || >=22.12.0"
   },
   "scripts": {
+    "test": "node --test",
     "release": "release-it -c ../../.release-it.json"
   }
 }

package/src/code-actions.js

@@ -40,6 +40,15 @@ export const createRemoveDependencyEdit = (document, uri, issue) => {
     const range = { start: { line: lineIndex, character: 0 }, end: { line: lineIndex + 1, character: 0 } };
     const edits = [TextEdit.del(range)];
 
+    if (lineIndex > 0 && !document.getText(range).trimEnd().endsWith(',')) {
+      const prevRange = { start: { line: lineIndex - 1, character: 0 }, end: { line: lineIndex, character: 0 } };
+      const prevLine = document.getText(prevRange).trimEnd();
+      if (prevLine.endsWith(',')) {
+        const start = { line: lineIndex - 1, character: prevLine.length - 1 };
+        edits.push(TextEdit.del({ start, end: { line: lineIndex - 1, character: prevLine.length } }));
+      }
+    }
+
     return { changes: { [uri]: edits } };
   } catch (_error) {
     return null;

package/src/diagnostics.js

@@ -5,14 +5,14 @@ import { DiagnosticSeverity, DiagnosticTag } from 'vscode-languageserver/node';
  * @import { Diagnostic } from 'vscode-languageserver';
  * @import { TextDocument } from 'vscode-languageserver-textdocument';
  * @import { Config } from './types.js';
- * @import { Issue, Rules } from 'knip/session';
+ * @import { Issue, IssueType, Rules } from 'knip/session';
  */
 
+/** Superseded by `editor.severity`; kept until the settings are removed */
 const dimmedIssueTypes = {
   exports: 'dimExports',
   types: 'dimTypes',
   enumMembers: 'dimEnumMembers',
-  classMembers: 'dimClassMembers',
   duplicates: 'dimDuplicates',
 };
 
@@ -23,6 +23,57 @@ const SEVERITY = {
   hint: DiagnosticSeverity.Hint,
 };
 
+const ABSOLUTE_SEVERITY = {
+  error: DiagnosticSeverity.Error,
+  warning: DiagnosticSeverity.Warning,
+  information: DiagnosticSeverity.Information,
+  hint: DiagnosticSeverity.Hint,
+};
+
+/** Loudest to quietest, so `downgrade` and `upgrade` can step along it */
+const SEVERITY_ORDER = [
+  DiagnosticSeverity.Error,
+  DiagnosticSeverity.Warning,
+  DiagnosticSeverity.Information,
+  DiagnosticSeverity.Hint,
+];
+
+/**
+ * @param {DiagnosticSeverity} severity
+ * @param {number} steps
+ * @returns {DiagnosticSeverity}
+ */
+const step = (severity, steps) => {
+  const index = SEVERITY_ORDER.indexOf(severity);
+  if (index === -1) return severity;
+  return SEVERITY_ORDER[Math.min(SEVERITY_ORDER.length - 1, Math.max(0, index + steps))];
+};
+
+/**
+ * Editor-only: `rules` decides what fails a run, this decides how the editor renders it.
+ * Most specific wins: the issue type, then a dim setting, then `*`, then `rules`.
+ * @param {IssueType} type
+ * @param {DiagnosticSeverity} base severity `rules` would give this issue type
+ * @param {Config} config
+ * @returns {DiagnosticSeverity}
+ */
+const resolveSeverity = (type, base, config) => {
+  const configured = config.editor.severity;
+  const isScalar = typeof configured === 'string';
+
+  const dimSetting = dimmedIssueTypes[type];
+  const isDimmed = dimSetting ? config.editor.exports.highlight[dimSetting] === true : false;
+
+  const value =
+    (isScalar ? undefined : configured?.[type]) ??
+    (isDimmed ? 'hint' : undefined) ??
+    (isScalar ? configured : configured?.['*']);
+
+  if (value === 'downgrade') return step(base, 1);
+  if (value === 'upgrade') return step(base, -1);
+  return ABSOLUTE_SEVERITY[value] ?? base;
+};
+
 /**
  * @param {Issue} issue
  * @param {Rules} rules
@@ -31,9 +82,14 @@ const SEVERITY = {
  * @returns {Diagnostic}
  */
 export const issueToDiagnostic = (issue, rules, config, document) => {
+  // unused files are informational by default: the whole file is the finding, not a symbol in it
+  const base = issue.type === 'files' ? DiagnosticSeverity.Information : SEVERITY[rules[issue.type]];
+  const severity = resolveSeverity(issue.type, base, config);
+
   if (issue.type === 'files' && document) {
     return {
-      severity: DiagnosticSeverity.Information,
+      severity,
+      tags: severity === DiagnosticSeverity.Hint ? [DiagnosticTag.Unnecessary] : undefined,
       range: {
         start: { line: 0, character: 0 },
         end: { line: 0, character: 1 },
@@ -44,16 +100,8 @@ export const issueToDiagnostic = (issue, rules, config, document) => {
     };
   }
 
-  /** @type {DiagnosticSeverity} */
-  let severity = SEVERITY[rules[issue.type]];
-
-  /** @type {DiagnosticTag[]} */
-  const tags = [];
-
-  if (dimmedIssueTypes[issue.type] && config.editor.exports.highlight[dimmedIssueTypes[issue.type]]) {
-    severity = DiagnosticSeverity.Hint;
-    tags.push(DiagnosticTag.Unnecessary);
-  }
+  // a hint is nearly invisible without it, and this is what makes `hint` fade the code
+  const tags = severity === DiagnosticSeverity.Hint ? [DiagnosticTag.Unnecessary] : [];
 
   const line = Math.max(0, (issue.line ?? 1) - 1);
   const start = Math.max(0, (issue.col ?? 0) - 1);

package/src/server.js

@@ -43,6 +43,7 @@ function readKnipVersion(resolvedPath) {
 const DEFAULT_CONFIG = {
   deferSession: false,
   editor: {
+    severity: 'default',
     exports: {
       codelens: { enabled: true },
       hover: { enabled: true, includeImportLocationSnippet: false, maxSnippets: 10, timeout: 300 },
@@ -51,7 +52,6 @@ const DEFAULT_CONFIG = {
         dimExports: false,
         dimTypes: false,
         dimEnumMembers: false,
-        dimClassMembers: false,
         dimDuplicates: false,
       },
     },
@@ -237,7 +237,7 @@ export class LanguageServer {
       } catch {}
     }
     this.connection.console.log(
-      `Using bundled knip${readKnipVersion(createRequire(__filename).resolve('knip/session'))}`
+      `Using bundled knip${readKnipVersion(createRequire(import.meta.url).resolve('knip/session'))}`
     );
     return { createOptions, createSession };
   }

package/src/types.d.ts

@@ -1,9 +1,12 @@
 import type { Issue, IssueType } from 'knip/session';
 
+export type EditorSeverity = 'default' | 'error' | 'warning' | 'information' | 'hint' | 'downgrade' | 'upgrade';
+
 export type Config = {
   deferSession: boolean;
   configFilePath?: string;
   editor: {
+    severity: EditorSeverity | Partial<Record<IssueType | '*', EditorSeverity>>;
     exports: {
       codelens: {
         enabled: boolean;
@@ -22,7 +25,6 @@ export type Config = {
         dimExports: boolean;
         dimTypes: boolean;
         dimEnumMembers: boolean;
-        dimClassMembers: boolean;
         dimDuplicates: boolean;
       };
     };

package/test/code-actions.test.js

@@ -0,0 +1,55 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { createRemoveDependencyEdit } from '../src/code-actions.js';
+
+const uri = 'file:///project/package.json';
+
+const manifest = (eol = '\n') =>
+  [
+    '{',
+    '  "name": "project",',
+    '  "dependencies": {',
+    '    "react": "^19.0.0",',
+    '    "lodash": "^4.17.21",',
+    '    "chalk": "^5.0.0"',
+    '  },',
+    '  "devDependencies": {',
+    '    "typescript": "^5.0.0"',
+    '  }',
+    '}',
+    '',
+  ].join(eol);
+
+const remove = (text, symbol) => {
+  const document = TextDocument.create(uri, 'json', 1, text);
+  const line = text.split(/\r?\n/).findIndex(l => l.includes(`"${symbol}"`)) + 1;
+  const edit = createRemoveDependencyEdit(document, uri, { type: 'dependencies', symbol, line });
+  return TextDocument.applyEdits(document, edit.changes[uri]);
+};
+
+for (const [label, eol] of [
+  ['LF', '\n'],
+  ['CRLF', '\r\n'],
+]) {
+  test(`removes first dependency (${label})`, () => {
+    const result = remove(manifest(eol), 'react');
+    assert.deepEqual(JSON.parse(result).dependencies, { lodash: '^4.17.21', chalk: '^5.0.0' });
+  });
+
+  test(`removes middle dependency (${label})`, () => {
+    const result = remove(manifest(eol), 'lodash');
+    assert.deepEqual(JSON.parse(result).dependencies, { react: '^19.0.0', chalk: '^5.0.0' });
+  });
+
+  test(`removes last dependency (${label})`, () => {
+    const result = remove(manifest(eol), 'chalk');
+    assert.deepEqual(JSON.parse(result).dependencies, { react: '^19.0.0', lodash: '^4.17.21' });
+    assert.ok(result.includes(`"lodash": "^4.17.21"${eol}  }`));
+  });
+
+  test(`removes sole dependency (${label})`, () => {
+    const result = remove(manifest(eol), 'typescript');
+    assert.deepEqual(JSON.parse(result).devDependencies, {});
+  });
+}

package/test/diagnostics.test.js

@@ -0,0 +1,149 @@
+import { readFileSync } from 'node:fs';
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { ISSUE_TYPES } from 'knip/session';
+import { DiagnosticSeverity, DiagnosticTag } from 'vscode-languageserver/node';
+import { issueToDiagnostic } from '../src/diagnostics.js';
+
+const manifest = JSON.parse(readFileSync(new URL('../../vscode-knip/package.json', import.meta.url), 'utf8'));
+const editorSettings = manifest.contributes.configuration.find(section => section.title === 'Editor').properties;
+
+const dimSettings = Object.keys(editorSettings)
+  .filter(key => key.includes('.highlight.dim'))
+  .map(key => key.slice(key.lastIndexOf('.') + 1));
+
+const toIssueType = setting => setting.replace(/^dim/, '').replace(/^./, first => first.toLowerCase());
+
+const NO_DIM = Object.fromEntries(dimSettings.map(setting => [setting, false]));
+
+/**
+ * @param {unknown} [severity]
+ * @param {Record<string, boolean>} [highlight]
+ */
+const config = (severity, highlight = NO_DIM) => ({ editor: { severity, exports: { highlight } } });
+
+const rules = { exports: 'error', types: 'warn', files: 'error', enumMembers: 'error', duplicates: 'error' };
+
+const unusedExport = { type: 'exports', symbol: 'unusedThing', line: 3, col: 14, filePath: '/project/module.ts' };
+const unusedType = { ...unusedExport, type: 'types' };
+const unusedFile = { type: 'files', symbol: 'unused.ts', filePath: '/project/unused.ts' };
+
+const document = { getText: () => '' };
+
+const severityOf = (issue, cfg, doc) => issueToDiagnostic(issue, rules, cfg, doc).severity;
+
+test('severity follows the rules by default', () => {
+  assert.equal(severityOf(unusedExport, config('default')), DiagnosticSeverity.Error);
+  assert.equal(severityOf(unusedType, config('default')), DiagnosticSeverity.Warning);
+});
+
+test('severity falls back to the rules when a client sends no setting', () => {
+  assert.equal(severityOf(unusedExport, config(undefined)), DiagnosticSeverity.Error);
+});
+
+test('a scalar applies to every issue type', () => {
+  assert.equal(severityOf(unusedExport, config('warning')), DiagnosticSeverity.Warning);
+  assert.equal(severityOf(unusedType, config('information')), DiagnosticSeverity.Information);
+  assert.equal(severityOf(unusedFile, config('hint'), document), DiagnosticSeverity.Hint);
+});
+
+test('a scalar raises issue types the rules made a warning', () => {
+  assert.equal(severityOf(unusedType, config('error')), DiagnosticSeverity.Error);
+});
+
+test('downgrade and upgrade step relative to the rules', () => {
+  assert.equal(severityOf(unusedExport, config('downgrade')), DiagnosticSeverity.Warning);
+  assert.equal(severityOf(unusedType, config('downgrade')), DiagnosticSeverity.Information);
+  assert.equal(severityOf(unusedType, config('upgrade')), DiagnosticSeverity.Error);
+});
+
+test('downgrade and upgrade stop at the ends of the scale', () => {
+  assert.equal(severityOf(unusedExport, config('upgrade')), DiagnosticSeverity.Error);
+  assert.equal(severityOf(unusedFile, config({ files: 'hint' }), document), DiagnosticSeverity.Hint);
+  assert.equal(severityOf(unusedFile, config({ files: 'downgrade' }), document), DiagnosticSeverity.Hint);
+});
+
+test('a map keyed by issue type beats the wildcard', () => {
+  const cfg = config({ '*': 'hint', exports: 'error' });
+
+  assert.equal(severityOf(unusedExport, cfg), DiagnosticSeverity.Error);
+  assert.equal(severityOf(unusedType, cfg), DiagnosticSeverity.Hint);
+});
+
+test('the wildcard alone covers every issue type', () => {
+  const cfg = config({ '*': 'warning' });
+
+  assert.equal(severityOf(unusedExport, cfg), DiagnosticSeverity.Warning);
+  assert.equal(severityOf(unusedType, cfg), DiagnosticSeverity.Warning);
+});
+
+test('issue types absent from a map follow the rules', () => {
+  const cfg = config({ exports: 'hint' });
+
+  assert.equal(severityOf(unusedType, cfg), DiagnosticSeverity.Warning);
+});
+
+test('unused files are information by default', () => {
+  assert.equal(severityOf(unusedFile, config('default'), document), DiagnosticSeverity.Information);
+  assert.equal(severityOf(unusedFile, config({ '*': 'warning' }), document), DiagnosticSeverity.Warning);
+});
+
+test('a hint fades the code, whichever value produced it', () => {
+  for (const severity of ['hint', { exports: 'hint' }, { '*': 'hint' }]) {
+    const diagnostic = issueToDiagnostic(unusedExport, rules, config(severity));
+
+    assert.equal(diagnostic.severity, DiagnosticSeverity.Hint);
+    assert.deepEqual(diagnostic.tags, [DiagnosticTag.Unnecessary]);
+  }
+});
+
+test('every contributed dim setting names a real issue type, and dims it', () => {
+  assert.ok(dimSettings.length > 0, 'no dim settings found in the extension manifest');
+
+  for (const setting of dimSettings) {
+    const type = toIssueType(setting);
+    assert.ok(ISSUE_TYPES.includes(type), `${setting} names "${type}", which is not a Knip issue type`);
+
+    const issue = { ...unusedExport, type };
+    const diagnostic = issueToDiagnostic(issue, rules, config('default', { ...NO_DIM, [setting]: true }));
+
+    assert.equal(diagnostic.severity, DiagnosticSeverity.Hint, setting);
+  }
+});
+
+test('a dim setting still dims, and beats the wildcard', () => {
+  const cfg = config({ '*': 'error' }, { ...NO_DIM, dimExports: true });
+  const diagnostic = issueToDiagnostic(unusedExport, rules, cfg);
+
+  assert.equal(diagnostic.severity, DiagnosticSeverity.Hint);
+  assert.deepEqual(diagnostic.tags, [DiagnosticTag.Unnecessary]);
+});
+
+test('an entry for the issue type beats a dim setting', () => {
+  const cfg = config({ exports: 'error' }, { ...NO_DIM, dimExports: true });
+
+  assert.equal(severityOf(unusedExport, cfg), DiagnosticSeverity.Error);
+});
+
+test('a diagnostic carries the position and description of its issue', () => {
+  const diagnostic = issueToDiagnostic(unusedExport, rules, config('default'));
+
+  assert.deepEqual(diagnostic.range, {
+    start: { line: 2, character: 13 },
+    end: { line: 2, character: 24 },
+  });
+  assert.equal(diagnostic.message, 'Unused export: unusedThing');
+  assert.equal(diagnostic.source, 'knip');
+  assert.equal(diagnostic.code, 'exports');
+  assert.equal(diagnostic.tags, undefined);
+});
+
+test('an unused file is reported at the top of the file', () => {
+  const diagnostic = issueToDiagnostic(unusedFile, rules, config('default'), document);
+
+  assert.deepEqual(diagnostic.range, {
+    start: { line: 0, character: 0 },
+    end: { line: 0, character: 1 },
+  });
+  assert.equal(diagnostic.message, 'Unused file');
+});

package/test/startup.test.js

@@ -0,0 +1,71 @@
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtempSync, 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 } from '../src/constants.js';
+
+const cli = fileURLToPath(new URL('../src/cli.js', import.meta.url));
+
+const encode = payload => {
+  const body = JSON.stringify({ jsonrpc: '2.0', ...payload });
+  return `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
+};
+
+test('falls back to bundled knip when the project has no local knip', async () => {
+  const cwd = mkdtempSync(path.join(tmpdir(), 'knip-ls-'));
+  writeFileSync(path.join(cwd, 'package.json'), '{"name":"standalone","main":"index.js"}');
+  writeFileSync(path.join(cwd, 'index.js'), '');
+
+  const server = spawn(process.execPath, [cli, '--stdio'], { cwd, stdio: ['pipe', 'pipe', 'pipe'] });
+  const logs = [];
+  let buffer = '';
+
+  const done = new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`Timeout. Logs:\n${logs.join('\n')}`)), 30_000);
+    server.stdout.on('data', chunk => {
+      buffer += chunk;
+      for (;;) {
+        const match = buffer.match(/Content-Length: (\d+)\r\n\r\n/);
+        if (!match || buffer.length < match.index + match[0].length + Number(match[1])) break;
+        const start = match.index + match[0].length;
+        const msg = JSON.parse(buffer.slice(start, start + Number(match[1])));
+        buffer = buffer.slice(start + Number(match[1]));
+        if (msg.method === 'window/logMessage') logs.push(msg.params.message);
+        if (msg.method === 'workspace/configuration') server.stdin.write(encode({ id: msg.id, result: [{}] }));
+        if (msg.method === NOTIFICATION_MODULE_GRAPH_BUILT) {
+          clearTimeout(timer);
+          resolve();
+        }
+      }
+    });
+  });
+
+  server.stdin.write(
+    encode({
+      id: 1,
+      method: 'initialize',
+      params: {
+        processId: process.pid,
+        capabilities: {},
+        workspaceFolders: [{ uri: pathToFileURL(cwd).href, name: 'standalone' }],
+      },
+    })
+  );
+  server.stdin.write(encode({ method: 'initialized', params: {} }));
+
+  try {
+    await done;
+  } finally {
+    server.kill();
+    rmSync(cwd, { recursive: true, force: true });
+  }
+
+  assert.ok(
+    logs.some(log => log.startsWith('Using bundled knip')),
+    logs.join('\n')
+  );
+  assert.ok(!logs.some(log => log.includes('ReferenceError')), logs.join('\n'));
+});