fix: report errors in spelling result. (#8381)

Jason3S · web-flow · commit fd9da285d8c9 · 2026-01-17T23:06:55.000+01:00
diff --git a/packages/cspell-lib/api/api.d.ts b/packages/cspell-lib/api/api.d.ts
diff --git a/packages/cspell-lib/fixtures/import-errors/README.md b/packages/cspell-lib/fixtures/import-errors/README.md
@@ -0,0 +1 @@
+# Handling Import Errors
diff --git a/packages/cspell-lib/fixtures/import-errors/cspell.config.yaml b/packages/cspell-lib/fixtures/import-errors/cspell.config.yaml
@@ -0,0 +1,9 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/streetsidesoftware/cspell/main/cspell.schema.json
+
+# The version of the configuration file format.
+version: '0.2'
+# The locale to use when spell checking. (e.g., en, en-GB, de-DE
+language: en
+import:
+  - ./missing-import.yaml
+  - ./missing-dict.yaml
diff --git a/packages/cspell-lib/fixtures/import-errors/file.txt b/packages/cspell-lib/fixtures/import-errors/file.txt
@@ -0,0 +1 @@
+# This file as some errrros
diff --git a/packages/cspell-lib/fixtures/import-errors/missing-dict.yaml b/packages/cspell-lib/fixtures/import-errors/missing-dict.yaml
@@ -0,0 +1,16 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/streetsidesoftware/cspell/main/cspell.schema.json
+
+# The version of the configuration file format.
+version: '0.2'
+# The locale to use when spell checking. (e.g., en, en-GB, de-DE
+language: en
+# Configuration or packages to import.
+import:
+  - ./cspell.config.yaml
+
+dictionaryDefinitions:
+  - name: my-dict
+    path: ./missing.txt
+
+dictionaries:
+  - my-dict
diff --git a/packages/cspell-lib/fixtures/import-errors/missing-import.yaml b/packages/cspell-lib/fixtures/import-errors/missing-import.yaml
@@ -0,0 +1,9 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/streetsidesoftware/cspell/main/cspell.schema.json
+
+# The version of the configuration file format.
+version: '0.2'
+# The locale to use when spell checking. (e.g., en, en-GB, de-DE
+language: en
+# Configuration or packages to import.
+import:
+  - ./missing.config.yaml
diff --git a/packages/cspell-lib/src/cspell-rpc/index.test.ts b/packages/cspell-lib/src/cspell-rpc/index.test.ts
@@ -6,7 +6,10 @@ import type { MessagePortLike } from './index.js';
 import { CSpellRPCClient } from './index.js';
 import { CSpellRPCServer } from './index.js';
 
+const packageUrl = new URL('../../package.json', import.meta.url);
+
 const oc = (...params: Parameters<typeof expect.objectContaining>) => expect.objectContaining(...params);
+const ac = (...params: Parameters<typeof expect.arrayContaining>) => expect.arrayContaining(...params);
 
 describe('Validate Client / Server communications', () => {
     test('Check creation', async () => {
@@ -35,6 +38,51 @@ describe('Validate Client / Server communications', () => {
         expect(result2).toBeDefined();
         expect(result2).toEqual(oc({ issues: [], errors: undefined }));
     });
+
+    const urlFixtures = new URL('fixtures/', packageUrl);
+    const urlSampleFilesWithIssues = new URL('docValidator/sample-files-with-issues/', urlFixtures);
+    const noIssues = { issues: [], errors: undefined, configErrors: undefined, dictionaryErrors: undefined };
+
+    const expectedFor = {
+        'WOX_Permissions.ps1': { ...noIssues, issues: ac([oc({ text: 'explicitily' })]) },
+        'import-errors/file.txt': {
+            ...noIssues,
+            configErrors: [
+                {
+                    filename: expect.stringContaining('missing.config.yaml'),
+                    error: oc({
+                        message: expect.stringContaining(
+                            'Failed to resolve configuration file: "./missing.config.yaml"',
+                        ),
+                    }),
+                },
+            ],
+            dictionaryErrors: new Map([['my-dict', [new Error('failed to load', { cause: expect.anything() })]]]),
+            errors: [
+                oc({
+                    message: expect.stringContaining('Failed to resolve configuration file: "./missing.config.yaml"'),
+                }),
+            ],
+        },
+    };
+
+    // cspell:ignore explicitily
+
+    test.each`
+        filename                    | rootUrl                     | expected
+        ${import.meta.url}          | ${import.meta.url}          | ${noIssues}
+        ${'WOX_Permissions.ps1'}    | ${urlSampleFilesWithIssues} | ${expectedFor['WOX_Permissions.ps1']}
+        ${'import-errors/file.txt'} | ${urlFixtures}              | ${expectedFor['import-errors/file.txt']}
+    `('spell document $filename', async ({ filename, rootUrl, expected }) => {
+        const { client } = createClientServerPair();
+        const api = client.getApi();
+        const uri = new URL(filename, rootUrl).href;
+
+        const doc = { uri };
+        const result = await api.spellCheckDocument(doc, {}, {});
+        const { issues, errors, configErrors, dictionaryErrors } = result;
+        expect({ issues, errors, configErrors, dictionaryErrors }).toEqual(expected);
+    });
 });
 
 interface ClientServerPair {
diff --git a/packages/cspell-lib/src/lib/spellCheckFile.ts b/packages/cspell-lib/src/lib/spellCheckFile.ts
@@ -7,6 +7,7 @@ import { isBinaryDoc } from './Document/isBinaryDoc.js';
 import { documentToTextDocument, resolveDocument } from './Document/resolveDocument.js';
 import { createTextDocument } from './Models/TextDocument.js';
 import { createPerfTimer } from './perf/index.js';
+import type { ImportFileRefWithError } from './Settings/index.js';
 import { cloneSettingsForExport } from './Settings/sanitizeSettings.js';
 import { determineTextDocumentSettings } from './textValidation/determineTextDocumentSettings.js';
 import type { DocumentValidatorOptions } from './textValidation/index.js';
@@ -54,6 +55,8 @@ export interface SpellCheckFileResult {
     issues: ValidationIssue[];
     checked: boolean;
     errors: Error[] | undefined;
+    configErrors?: ImportFileRefWithError[] | undefined;
+    dictionaryErrors?: Map<string, Error[]> | undefined;
     perf?: SpellCheckFilePerf;
 }
 
@@ -198,6 +201,8 @@ async function spellCheckFullDocument(
             issues: [],
             checked: false,
             errors: docValidator.errors,
+            configErrors: docValidator.getConfigErrors(),
+            dictionaryErrors: docValidator.getDictionaryErrors(),
             perf,
         };
     }
@@ -216,6 +221,8 @@ async function spellCheckFullDocument(
         issues,
         checked: docValidator.shouldCheckDocument(),
         errors: undefined,
+        configErrors: docValidator.getConfigErrors(),
+        dictionaryErrors: docValidator.getDictionaryErrors(),
         perf,
     };
     timer.end();
diff --git a/packages/cspell-lib/src/lib/textValidation/docValidator.ts b/packages/cspell-lib/src/lib/textValidation/docValidator.ts
@@ -20,6 +20,7 @@ import type { TextDocument, TextDocumentLine, TextDocumentRef } from '../Models/
 import { documentUriToURL, updateTextDocument } from '../Models/TextDocument.js';
 import type { ValidationIssue } from '../Models/ValidationIssue.js';
 import { createPerfTimer, measurePerf } from '../perf/index.js';
+import type { ImportFileRefWithError } from '../Settings/index.js';
 import {
     extractImportErrors,
     finalizeSettings,
@@ -500,6 +501,22 @@ export class DocumentValidator {
         return this._preparations.docSettings;
     }
 
+    public getConfigErrors(): ImportFileRefWithError[] | undefined {
+        const settings = this.getFinalizedDocSettings();
+        const errors = extractImportErrors(settings);
+        return errors.length ? errors : undefined;
+    }
+
+    public getDictionaryErrors(): Map<string, Error[]> | undefined {
+        assert(this._ready);
+        assert(this._preparations, ERROR_NOT_PREPARED);
+        const { dictionary } = this._preparations;
+        const errors = dictionary.dictionaries
+            .map((dict) => [dict.name, dict.getErrors?.()] as const)
+            .filter((entry): entry is [string, Error[]] => (entry[1] && entry[1].length > 0) || false);
+        return errors.length ? new Map(errors) : undefined;
+    }
+
     /**
      * Returns true if the final result of the configuration calculation results
      * in the document being enabled. Note: in some cases, checking the document
diff --git a/packages/cspell/src/cspell-api/cspell-api.ts b/packages/cspell/src/cspell-api/cspell-api.ts
@@ -0,0 +1,18 @@
+import { spellCheckDocument, spellCheckDocumentRPC } from 'cspell-lib';
+import type { CSpellRPCApi } from 'cspell-lib/cspell-rpc';
+
+export interface CSpellAPI extends Pick<CSpellRPCApi, 'spellCheckDocument'> {}
+
+const usePRC = false;
+
+const api = {
+    spellCheckDocument,
+} as const;
+
+export const apiRPC: CSpellAPI = {
+    spellCheckDocument: spellCheckDocumentRPC,
+} as const;
+
+export function getCSpellAPI(): Promise<CSpellAPI> {
+    return Promise.resolve(usePRC ? apiRPC : api);
+}
diff --git a/packages/cspell/src/cspell-api/index.ts b/packages/cspell/src/cspell-api/index.ts
@@ -0,0 +1,2 @@
+export type { CSpellAPI } from './cspell-api.js';
+export { getCSpellAPI } from './cspell-api.js';
diff --git a/packages/cspell/src/lint/lint.ts b/packages/cspell/src/lint/lint.ts
@@ -274,7 +274,7 @@ export async function runLint(cfg: LintRequest): Promise<RunResult> {
             reporter.info(`Config Files Found:\n    ${relativeToCwd(configInfo.source)}\n`, MessageTypes.Info);
         }
 
-        const configErrors = await countConfigErrors(configInfo, processFileOptions);
+        const configErrors = countConfigErrors(configInfo, processFileOptions);
         if (configErrors && cfg.options.exitCode !== false && !cfg.options.continueOnError) {
             return runResult({ errors: configErrors });
         }
diff --git a/packages/cspell/src/lint/processFile.ts b/packages/cspell/src/lint/processFile.ts
@@ -5,20 +5,15 @@ import type {
     CSpellSettings,
     CSpellSettingsWithSourceTrace,
     Document,
+    ImportFileRefWithError,
     Issue,
     SpellCheckFileResult,
     TextDocumentOffset,
     ValidationIssue,
 } from 'cspell-lib';
-import {
-    extractDependencies,
-    extractImportErrors,
-    getDictionary,
-    MessageTypes,
-    spellCheckDocument,
-    Text as cspellText,
-} from 'cspell-lib';
+import { extractDependencies, extractImportErrors, MessageTypes, Text as cspellText } from 'cspell-lib';
 
+import { getCSpellAPI } from '../cspell-api/index.js';
 import type { CSpellLintResultCache } from '../util/cache/CSpellLintResultCache.js';
 import type { ConfigInfo } from '../util/configFileHelper.js';
 import { toError } from '../util/errors.js';
@@ -54,6 +49,8 @@ export async function processFile(
 
     const { reporter, cfg, configInfo } = processFileOptions;
 
+    const { spellCheckDocument } = await getCSpellAPI();
+
     const getElapsedTimeMs = getTimeMeasurer();
     const reportIssueOptions = prefetch?.reportIssueOptions;
     const cachedResult = await cache.getCachedLintResults(filename);
@@ -119,7 +116,8 @@ export async function processFile(
         spellResult.settingsUsed || configInfo.config,
         reportIssueOptions,
     );
-    result.configErrors += await reportConfigurationErrors(config, processFileOptions);
+
+    result.configErrors += reportSpellingResultConfigErrors(spellResult, processFileOptions);
 
     reportCheckResult(result, doc, spellResult, config, processFileOptions);
 
@@ -179,12 +177,13 @@ function calcDependencies(config: CSpellSettings): ConfigDependencies {
     return { files: [...configFiles, ...dictionaryFiles] };
 }
 
-export async function reportConfigurationErrors(
-    config: CSpellSettings,
-    processFileOptions: ProcessFileOptions,
-): Promise<number> {
-    const { reporter, configErrors } = processFileOptions;
+function reportConfigurationErrors(config: CSpellSettings, processFileOptions: ProcessFileOptions): number {
     const errors = extractImportErrors(config);
+    return reportImportErrors(errors, processFileOptions);
+}
+
+function reportImportErrors(errors: ImportFileRefWithError[], processFileOptions: ProcessFileOptions): number {
+    const { reporter, configErrors } = processFileOptions;
     let count = 0;
     errors.forEach((ref) => {
         const key = ref.error.toString();
@@ -194,22 +193,31 @@ export async function reportConfigurationErrors(
         reporter.error('Configuration', ref.error);
     });
 
-    const dictCollection = await getDictionary(config);
-    dictCollection.dictionaries.forEach((dict) => {
-        const dictErrors = dict.getErrors?.() || [];
-        const msg = `Dictionary Error with (${dict.name})`;
+    return count;
+}
+
+function reportSpellingResultConfigErrors(
+    spellResult: Partial<SpellCheckFileResult>,
+    processFileOptions: ProcessFileOptions,
+): number {
+    const { reporter, configErrors } = processFileOptions;
+    let count = reportImportErrors(spellResult.configErrors || [], processFileOptions);
+
+    const dictionaryErrors = [...(spellResult.dictionaryErrors || [])];
+    for (const [dictName, dictErrors] of dictionaryErrors) {
+        const msg = `Dictionary Error with (${dictName})`;
         dictErrors.forEach((error) => {
             const key = msg + error.toString();
             if (configErrors.has(key)) return;
             configErrors.add(key);
             count += 1;
             reporter.error(msg, error);
         });
-    });
+    }
 
     return count;
 }
 
-export function countConfigErrors(configInfo: ConfigInfo, processFileOptions: ProcessFileOptions): Promise<number> {
+export function countConfigErrors(configInfo: ConfigInfo, processFileOptions: ProcessFileOptions): number {
     return reportConfigurationErrors(configInfo.config, processFileOptions);
 }
