Allow user defined validation categories (#1837)

Author: ydaveluy

packages/langium/src/test/langium-test.ts

@@ -556,10 +556,11 @@ export type ValidationHelperOptions = ParseHelperOptions & { failOnParsingErrors
 export function validationHelper<T extends AstNode = AstNode>(services: LangiumCoreServices): (input: string, options?: ValidationHelperOptions) => Promise<ValidationResult<T>> {
     const parse = parseHelper<T>(services);
     return async (input, options) => {
-        const document = await parse(input, {
+        const parseOptions: ValidationHelperOptions = {
             ...(options ?? {}),
-            validation: true
-        });
+        };
+        parseOptions.validation ??= true;
+        const document = await parse(input, parseOptions);
         const result = {
             document,
             diagnostics: document.diagnostics ?? [],

packages/langium/src/validation/validation-registry.ts

@@ -98,6 +98,8 @@ export type ValidationChecks<T> = {
 }
 
 /**
+ * There are 3 pre-defined categories: `fast`, `slow` and `built-in`.
+ *
  * `fast` checks can be executed after every document change (i.e. as the user is typing). If a check
  * is too slow it can delay the response to document changes, yielding bad user experience. By marking
  * it as `slow`, it will be skipped for normal as-you-type validation. Then it's up to you when to
@@ -106,8 +108,13 @@ export type ValidationChecks<T> = {
  *
  * `built-in` checks are errors produced by the lexer, the parser, or the linker. They cannot be used
  * for custom validation checks.
+ *
+ * You can also provide user-defined categories. These check will be skipped by default. Then it's up
+ * to you to schedule these checks: after the fast checks are done, or after saving a document,
+ * or with an explicit command, etc.
  */
-export type ValidationCategory = 'fast' | 'slow' | 'built-in'
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type ValidationCategory = 'fast' | 'slow' | 'built-in' | (string & {});
 
 export namespace ValidationCategory {
     export const all: readonly ValidationCategory[] = ['fast', 'slow', 'built-in'];

packages/langium/test/validation/document-validator.test.ts

@@ -8,7 +8,7 @@ import { AstUtils } from 'langium';
 import type { AstNode, ValidationAcceptor, ValidationChecks } from 'langium';
 import { createServicesForGrammar } from 'langium/grammar';
 import type { LangiumServices } from 'langium/lsp';
-import type { ValidationResult } from 'langium/test';
+import type { ValidationHelperOptions, ValidationResult } from 'langium/test';
 import { validationHelper } from 'langium/test';
 import { beforeAll, describe, expect, test } from 'vitest';
 import { Position, Range } from 'vscode-languageserver';
@@ -259,4 +259,82 @@ describe('Register Before/AfterDocument logic for validations with state', () =>
         });
     });
 
+    describe('Custom validation categories', () => {
+
+        const grammar = `grammar Test
+    
+        entry Model:
+            'model' name=ID;
+
+        hidden terminal WS: /\\s+/;
+        terminal ID: /[_a-zA-Z][\\w_]*/;
+        `;
+
+        let validate: (input: string, options?: ValidationHelperOptions) => Promise<ValidationResult<AstNode>>;
+
+        beforeAll(async () => {
+            const services = await createServicesForGrammar({
+                grammar
+            });
+            const validationChecksUser: ValidationChecks<object> = {
+                AstNode: [
+                    (node, accept) => {
+                        accept('error', 'TEST', { node });
+                    }
+                ]
+            };
+            services.validation.ValidationRegistry.register(validationChecksUser, services.validation.ValidationRegistry, 'user');
+            const validationChecksFast: ValidationChecks<object> = {
+                AstNode: [
+                    (node, accept) => {
+                        accept('warning', 'TEST', { node });
+                    }
+                ]
+            };
+            services.validation.ValidationRegistry.register(validationChecksFast);
+
+            validate = validationHelper(services);
+        });
+
+        test('empty categories', async () => {
+            const validationResult = await validate('model test', {validation:{categories:[]}});
+            const diagnostics = validationResult.diagnostics;
+            expect(diagnostics).toHaveLength(0);
+            expect(diagnostics.filter(d => d.severity === 1)).toHaveLength(0); // 0 error
+            expect(diagnostics.filter(d => d.severity === 2)).toHaveLength(0); // 0 warning
+        });
+
+        test('fast category', async () => {
+            const validationResult = await validate('model test', {validation:{categories:['fast']}});
+            const diagnostics = validationResult.diagnostics;
+            expect(diagnostics).toHaveLength(1);
+            expect(diagnostics.filter(d => d.severity === 1)).toHaveLength(0); // 0 error
+            expect(diagnostics.filter(d => d.severity === 2)).toHaveLength(1); // 1 warning
+        });
+
+        test('user category', async () => {
+            const validationResult = await validate('model test', {validation:{categories:['user']}});
+            const diagnostics = validationResult.diagnostics;
+            expect(diagnostics).toHaveLength(1);
+            expect(diagnostics.filter(d => d.severity === 1)).toHaveLength(1); // 1 error
+            expect(diagnostics.filter(d => d.severity === 2)).toHaveLength(0); // 0 warning
+        });
+
+        test('user&fast categories', async () => {
+            const validationResult = await validate('model test', {validation:{categories:['user', 'fast']}});
+            const diagnostics = validationResult.diagnostics;
+            expect(diagnostics).toHaveLength(2);
+            expect(diagnostics.filter(d => d.severity === 1)).toHaveLength(1); // 1 error
+            expect(diagnostics.filter(d => d.severity === 2)).toHaveLength(1); // 1 warning
+        });
+
+        test('default categories', async () => {
+            const validationResult = await validate('model test');
+            const diagnostics = validationResult.diagnostics;
+            expect(diagnostics).toHaveLength(2);
+            expect(diagnostics.filter(d => d.severity === 1)).toHaveLength(1); // 1 error
+            expect(diagnostics.filter(d => d.severity === 2)).toHaveLength(1); // 1 warning
+        });
+    });
+
 });