@knip/language-server 3.0.5 → 3.1.0

package/LICENSE

@@ -1,6 +1,6 @@
 ISC License (ISC)
 
-Copyright 2022-2025 Lars Kappert
+Copyright 2022-2026 Lars Kappert
 
 Permission to use, copy, modify, and/or distribute this software for any purpose
 with or without fee is hereby granted, provided that the above copyright notice

package/package.json

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

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,
       },
     },

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/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');
+});