Add more opportunities for cancellation for validate()

.gitignore

@@ -48,6 +48,9 @@ Generated\ Files/
 TestResult.xml
 nunit-*.xml
 
+# Task-specific temporary files
+.copilot-current-task.md
+
 # Build Results of an ATL Project
 [Dd]ebugPS/
 [Rr]eleasePS/

.vscode/settings.json

@@ -6,8 +6,8 @@
     "editor.formatOnSave": true,
 
     // VS Code Test Runner configuration
-    "testing.openTesting": "openOnTestStart",
     "testing.automaticallyOpenPeekView": "failureInVisibleDocument",
+    "testing.automaticallyOpenTestResults": "openOnTestStart",
     "testing.defaultGutterClickAction": "run",
     "testing.followRunningTest": true,
 

eslint.config.js

@@ -35,6 +35,7 @@ module.exports = [
                 __dirname: "readonly",
                 module: "readonly",
                 setTimeout: "readonly",
+                console: "readonly",
             },
         },
         plugins: {

src/powerquery-language-services/inspection/invokeExpression/invokeExpression.ts

@@ -93,6 +93,8 @@ async function inspectInvokeExpression(
         await tryType(settings, nodeIdMapCollection, previousNode.node.id, typeCache),
     );
 
+    settings.cancellationToken?.throwIfCancelled();
+
     let invokeExpressionArgs: InvokeExpressionArguments | undefined;
 
     if (TypeUtils.isDefinedFunction(functionType)) {
@@ -110,6 +112,8 @@ async function inspectInvokeExpression(
 
         const givenArguments: ReadonlyArray<TXorNode> = iterableArguments.slice(0, givenArgumentTypes.length);
 
+        settings.cancellationToken?.throwIfCancelled();
+
         const [numMinExpectedArguments, numMaxExpectedArguments]: [number, number] =
             getNumExpectedArguments(functionType);
 
@@ -166,6 +170,8 @@ async function getIsNameInLocalScope(
         initialCorrelationId: trace.id,
     };
 
+    settings.cancellationToken?.throwIfCancelled();
+
     // Try to find out if the identifier is a local or external name.
     if (name !== undefined) {
         // Seed local scope
@@ -211,6 +217,8 @@ async function getArgumentTypes(
     const result: Type.TPowerQueryType[] = [];
 
     for (const xorNode of argXorNodes) {
+        settings.cancellationToken?.throwIfCancelled();
+
         // eslint-disable-next-line no-await-in-loop
         const triedArgType: TriedType = await tryType(settings, nodeIdMapCollection, xorNode.node.id, typeCache);
 

src/powerquery-language-services/promiseUtils.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import { ICancellationToken } from "@microsoft/powerquery-parser";
+
+/**
+ * Sequential processing with cancellation support - often better than Promise.all
+ * for cancellation scenarios because we can stop between each operation.
+ */
+export async function processSequentiallyWithCancellation<T, R>(
+    items: T[],
+    processor: (item: T) => Promise<R>,
+    cancellationToken?: ICancellationToken,
+): Promise<R[]> {
+    const results: R[] = [];
+
+    for (const item of items) {
+        cancellationToken?.throwIfCancelled();
+        // eslint-disable-next-line no-await-in-loop
+        const result: R = await processor(item);
+        results.push(result);
+    }
+
+    return results;
+}

src/powerquery-language-services/validate/validate.ts

@@ -1,13 +1,15 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
+import { CommonError, Result, ResultUtils } from "@microsoft/powerquery-parser";
 import { NodeIdMap, ParseError, ParseState } from "@microsoft/powerquery-parser/lib/powerquery-parser/parser";
 import { Diagnostic } from "vscode-languageserver-types";
 import { TextDocument } from "vscode-languageserver-textdocument";
 import { Trace } from "@microsoft/powerquery-parser/lib/powerquery-parser/common/trace";
 
+import * as PromiseUtils from "../promiseUtils";
+
 import { Analysis, AnalysisSettings, AnalysisUtils } from "../analysis";
-import { CommonError, Result, ResultUtils } from "@microsoft/powerquery-parser";
 import { TypeCache } from "../inspection";
 import { validateDuplicateIdentifiers } from "./validateDuplicateIdentifiers";
 import { validateFunctionExpression } from "./validateFunctionExpression";
@@ -36,58 +38,69 @@ export function validate(
         };
 
         const analysis: Analysis = AnalysisUtils.analysis(textDocument, analysisSettings);
+
         const parseState: ParseState | undefined = ResultUtils.assertOk(await analysis.getParseState());
+        validationSettings.cancellationToken?.throwIfCancelled();
+
         const parseError: ParseError.ParseError | undefined = ResultUtils.assertOk(await analysis.getParseError());
+        validationSettings.cancellationToken?.throwIfCancelled();
 
         if (parseState === undefined) {
             trace.exit();
 
             return undefined;
         }
 
-        let functionExpressionDiagnostics: Diagnostic[];
-        let invokeExpressionDiagnostics: Diagnostic[];
-        let unknownIdentifiersDiagnostics: Diagnostic[];
-
         const nodeIdMapCollection: NodeIdMap.Collection = parseState.contextState.nodeIdMapCollection;
         const typeCache: TypeCache = analysis.getTypeCache();
 
-        if (validationSettings.checkInvokeExpressions && nodeIdMapCollection) {
-            functionExpressionDiagnostics = validateFunctionExpression(validationSettings, nodeIdMapCollection);
+        // Define validation operations to run sequentially
+        const validationOperations: (() => Promise<Diagnostic[]>)[] = [
+            // Parse validation (if there are parse errors)
+            async (): Promise<Diagnostic[]> => await validateParse(parseError, updatedSettings),
+        ];
 
-            invokeExpressionDiagnostics = await validateInvokeExpression(
-                validationSettings,
-                nodeIdMapCollection,
-                typeCache,
+        // Add conditional validations based on settings
+        if (validationSettings.checkForDuplicateIdentifiers && nodeIdMapCollection) {
+            validationOperations.push(
+                async (): Promise<Diagnostic[]> =>
+                    await validateDuplicateIdentifiers(
+                        textDocument,
+                        nodeIdMapCollection,
+                        updatedSettings,
+                        validationSettings.cancellationToken,
+                    ),
+            );
+        }
+
+        if (validationSettings.checkInvokeExpressions && nodeIdMapCollection) {
+            validationOperations.push(
+                async (): Promise<Diagnostic[]> =>
+                    await validateFunctionExpression(validationSettings, nodeIdMapCollection),
+                async (): Promise<Diagnostic[]> =>
+                    await validateInvokeExpression(validationSettings, nodeIdMapCollection, typeCache),
             );
-        } else {
-            functionExpressionDiagnostics = [];
-            invokeExpressionDiagnostics = [];
         }
 
         if (validationSettings.checkUnknownIdentifiers && nodeIdMapCollection) {
-            unknownIdentifiersDiagnostics = await validateUnknownIdentifiers(
-                validationSettings,
-                nodeIdMapCollection,
-                typeCache,
+            validationOperations.push(
+                async (): Promise<Diagnostic[]> =>
+                    await validateUnknownIdentifiers(validationSettings, nodeIdMapCollection, typeCache),
             );
-        } else {
-            unknownIdentifiersDiagnostics = [];
         }
 
+        // Execute all validation operations sequentially with cancellation support
+        const allDiagnostics: Diagnostic[][] = await PromiseUtils.processSequentiallyWithCancellation(
+            validationOperations,
+            (operation: () => Promise<Diagnostic[]>) => operation(),
+            validationSettings.cancellationToken,
+        );
+
+        // Flatten all diagnostics into a single array
+        const flattenedDiagnostics: Diagnostic[] = allDiagnostics.flat();
+
         const result: ValidateOk = {
-            diagnostics: [
-                ...validateDuplicateIdentifiers(
-                    textDocument,
-                    nodeIdMapCollection,
-                    updatedSettings,
-                    validationSettings.cancellationToken,
-                ),
-                ...(await validateParse(parseError, updatedSettings)),
-                ...functionExpressionDiagnostics,
-                ...invokeExpressionDiagnostics,
-                ...unknownIdentifiersDiagnostics,
-            ],
+            diagnostics: flattenedDiagnostics,
             hasSyntaxError: parseError !== undefined,
         };