@zzzen/pyright-internal 1.2.0-dev.20261011 → 1.2.0-dev.20261101

package/dist/common/windowsProcessTree.json

@@ -9,6 +9,7 @@
         "{",
         "    private const uint QueryAccess = 0x1000 | 0x100000;",
         "    private const uint ControlAccess = QueryAccess | 0x0001 | 0x0800;",
+        "    private const int ProcessIsTerminating = unchecked((int)0xC000010A);",
         "    private IntPtr handle;",
         "    private bool controlled;",
         "    private bool suspended;",
@@ -51,6 +52,18 @@
         "        public long CreationTimeUtcTicks;",
         "    }",
         "",
+        "    public sealed class CandidateOpenException : Win32Exception",
+        "    {",
+        "        public readonly int ProcessId;",
+        "",
+        "        public CandidateOpenException(int error, int processId)",
+        "            : base(error, \"Cannot pin candidate process \" + processId + \" (Win32 error \" + error + \": \" + new Win32Exception(error).Message + \")\")",
+        "        {",
+        "            ProcessId = processId;",
+        "            if (error == 87 && processId > 0) Data[\"PylanceAbsentProcessId\"] = processId;",
+        "        }",
+        "    }",
+        "",
         "    [DllImport(\"kernel32.dll\", SetLastError = true)]",
         "    private static extern IntPtr OpenProcess(uint access, bool inherit, int pid);",
         "    [DllImport(\"kernel32.dll\", SetLastError = true)]",
@@ -99,7 +112,7 @@
         "        if (value == IntPtr.Zero)",
         "        {",
         "            int error = Marshal.GetLastWin32Error();",
-        "            throw new Win32Exception(error, \"Cannot pin candidate process \" + pid + \" (Win32 error \" + error + \": \" + new Win32Exception(error).Message + \")\");",
+        "            throw new CandidateOpenException(error, pid);",
         "        }",
         "        return new PylanceOwnedWindowsProcess(value);",
         "    }",
@@ -141,18 +154,28 @@
         "        finally { if (value != IntPtr.Zero) CloseHandle(value); }",
         "    }",
         "",
-        "    public void Suspend()",
+        "    public enum SuspendResult { AlreadyExited, Suspended, ExitedDuringSuspend }",
+        "",
+        "    public SuspendResult Suspend(int terminatingWaitMilliseconds)",
         "    {",
-        "        if (HasExited) return;",
+        "        if (HasExited) return SuspendResult.AlreadyExited;",
         "        AcquireControl();",
-        "        CheckStatus(NtSuspendProcess(handle), \"suspend owned process \" + Id);",
+        "        int status = NtSuspendProcess(handle);",
+        "        if (status == ProcessIsTerminating)",
+        "        {",
+        "            if (!WaitForExit(terminatingWaitMilliseconds))",
+        "                throw new InvalidOperationException(\"Owned process \" + Id + \" is terminating but has not exited; cleanup is incomplete.\");",
+        "            return SuspendResult.ExitedDuringSuspend;",
+        "        }",
+        "        CheckStatus(status, \"suspend owned process \" + Id);",
         "        suspended = true;",
+        "        return SuspendResult.Suspended;",
         "    }",
         "",
         "    public void Resume()",
         "    {",
         "        if (!suspended) return;",
-        "        if (!HasExited) CheckStatus(NtResumeProcess(handle), \"resume owned process \" + Id);",
+        "        if (!HasExited) CheckControlStatus(NtResumeProcess(handle), \"resume owned process \" + Id);",
         "        suspended = false;",
         "    }",
         "",
@@ -218,6 +241,14 @@
         "        }",
         "    }",
         "",
+        "    private static bool CheckControlStatus(int status, string operation)",
+        "    {",
+        "        // Exit can start after HasExited; the tree must still wait for the retained handle to signal.",
+        "        if (status == ProcessIsTerminating) return false;",
+        "        CheckStatus(status, operation);",
+        "        return true;",
+        "    }",
+        "",
         "    private static void CheckStatus(int status, string operation)",
         "    {",
         "        if (status < 0) throw new InvalidOperationException(\"Cannot \" + operation + \" (NTSTATUS 0x\" + status.ToString(\"X8\") + \").\");",
@@ -230,6 +261,99 @@
         "}"
     ],
     "functions": [
+        "function New-OwnedWindowsProcessLineageDiagnostics {",
+        "    param(",
+        "        [Parameter(Mandatory = $true)] [hashtable] $Known,",
+        "        [Parameter(Mandatory = $true)] [object[]] $Hints,",
+        "        [Parameter(Mandatory = $true)] $Parent,",
+        "        [Parameter(Mandatory = $true)] [int] $Round,",
+        "        [Parameter(Mandatory = $true)] [int] $HintIndex,",
+        "        [Parameter(Mandatory = $true)] [int] $HintId,",
+        "        [Parameter(Mandatory = $true)] [int] $HintParentId,",
+        "        [Parameter(Mandatory = $true)] [long] $HintBirth,",
+        "        [Parameter(Mandatory = $true)] [string] $Identity",
+        "    )",
+        "    $parentMatches = [System.Collections.Generic.List[object]]::new()",
+        "    $parentMatchesTruncated = $false",
+        "    for ($index = 0; $index -lt $Hints.Count; $index++) {",
+        "        $entry = $Hints[$index]",
+        "        if ([int]$entry.Id -ne $HintParentId) { continue }",
+        "        if ($parentMatches.Count -ge 4) { $parentMatchesTruncated = $true; continue }",
+        "        $parentMatches.Add([ordered]@{",
+        "            snapshotIndex = $index",
+        "            processId = [string][int]$entry.Id",
+        "            parentProcessId = [string][int]$entry.ParentId",
+        "            creationTimeUtcTicks = [string][long]$entry.CreationTimeUtcTicks",
+        "        })",
+        "    }",
+        "    $chain = [System.Collections.Generic.List[object]]::new()",
+        "    $cursor = $Parent",
+        "    for ($depth = 0; $null -ne $cursor -and $depth -lt 16; $depth++) {",
+        "        $chain.Add([ordered]@{",
+        "            processId = [string][int]$cursor.Id",
+        "            parentProcessId = [string][int]$cursor.ParentId",
+        "            creationTimeUtcTicks = [string][long]$cursor.CreationTimeUtcTicks",
+        "            acceptedSnapshotGeneration = [int]$cursor.SnapshotGeneration",
+        "            acceptedSnapshotIndex = [int]$cursor.SnapshotIndex",
+        "            nativeOpenOutcome = [string]$cursor.OpenOutcome",
+        "        })",
+        "        if (!$Known.ContainsKey([int]$cursor.ParentId)) { $cursor = $null; break }",
+        "        $cursor = $Known[[int]$cursor.ParentId]",
+        "    }",
+        "    $chainTruncated = $null -ne $cursor",
+        "    $root = @($Known.Values | Where-Object { $_.Depth -eq 0 })[0]",
+        "    $generationMatches = $Parent.SnapshotGeneration -eq $Round",
+        "    $frozenChildIdentityPresent = $Parent.AllowedChildren.ContainsKey($Identity)",
+        "    $exactParentIdentityPresent = $false",
+        "    foreach ($match in $parentMatches) {",
+        "        if ($match.creationTimeUtcTicks -eq [string][long]$Parent.CreationTimeUtcTicks) {",
+        "            $exactParentIdentityPresent = $true",
+        "            break",
+        "        }",
+        "    }",
+        "    $diagnostics = [ordered]@{",
+        "        version = 1",
+        "        root = [ordered]@{",
+        "            processId = [string][int]$root.Id",
+        "            creationTimeUtcTicks = [string][long]$root.CreationTimeUtcTicks",
+        "        }",
+        "        rejectedHint = [ordered]@{",
+        "            processId = [string]$HintId",
+        "            parentProcessId = [string]$HintParentId",
+        "            creationTimeUtcTicks = [string]$HintBirth",
+        "            snapshotGeneration = $Round",
+        "            snapshotIndex = $HintIndex",
+        "            nativeOpenOutcome = 'not-attempted-lineage-guard'",
+        "        }",
+        "        vanishedParent = [ordered]@{",
+        "            processId = [string][int]$Parent.Id",
+        "            parentProcessId = [string][int]$Parent.ParentId",
+        "            creationTimeUtcTicks = [string][long]$Parent.CreationTimeUtcTicks",
+        "            acceptedSnapshotGeneration = [int]$Parent.SnapshotGeneration",
+        "            acceptedSnapshotIndex = [int]$Parent.SnapshotIndex",
+        "            nativeOpenOutcome = [string]$Parent.OpenOutcome",
+        "        }",
+        "        currentSnapshot = [ordered]@{",
+        "            generation = $Round",
+        "            entryCount = $Hints.Count",
+        "            exactVanishedParentIdentityPresent = $exactParentIdentityPresent",
+        "            vanishedParentPidMatches = @($parentMatches.ToArray())",
+        "            vanishedParentPidMatchesTruncated = $parentMatchesTruncated",
+        "        }",
+        "        failedOwnershipPredicate = [ordered]@{",
+        "            expression = 'parentSnapshotGenerationMatches && frozenChildIdentityPresent'",
+        "            parentSnapshotGenerationMatches = $generationMatches",
+        "            frozenChildIdentityPresent = $frozenChildIdentityPresent",
+        "            rejectedIdentity = $Identity",
+        "        }",
+        "        parentChainOrder = 'vanished-parent-to-root'",
+        "        parentChain = @($chain.ToArray())",
+        "        parentChainTruncated = $chainTruncated",
+        "    }",
+        "    $json = ConvertTo-Json -InputObject $diagnostics -Compress -Depth 6",
+        "    return $json",
+        "}",
+        "",
         "function Stop-OwnedWindowsProcessTree {",
         "    param(",
         "        [Parameter(Mandatory = $true)] $Root,",
@@ -240,48 +364,163 @@
         "    $watch = [System.Diagnostics.Stopwatch]::StartNew()",
         "    $held = [System.Collections.Generic.List[object]]::new()",
         "    $known = @{}",
+        "    $missing = @{}",
         "    $failure = $null",
         "    $cleanupErrors = [System.Collections.Generic.List[string]]::new()",
         "    try {",
         "        if ($Root.Id -eq $PID) { throw 'Refusing to terminate the cleanup process.' }",
         "        $retainedRoot = $Root.Retain()",
-        "        $rootEntry = [PSCustomObject]@{ Process = $retainedRoot; Depth = 0 }",
+        "        $rootEntry = [PSCustomObject]@{",
+        "            Process = $retainedRoot",
+        "            Id = [int]$retainedRoot.Id",
+        "            CreationTimeUtcTicks = [long]$retainedRoot.CreationTimeUtcTicks",
+        "            Depth = 0",
+        "            ParentId = [int]$retainedRoot.ParentId",
+        "            SnapshotGeneration = -1",
+        "            SnapshotIndex = -1",
+        "            OpenOutcome = 'retained-root'",
+        "            AllowedChildren = $null",
+        "        }",
         "        $held.Add($rootEntry)",
         "        $known[[int]$retainedRoot.Id] = $rootEntry",
-        "        $retainedRoot.Suspend()",
+        "        $remaining = [Math]::Max(1, $TimeoutMilliseconds - [int]$watch.ElapsedMilliseconds)",
+        "        $null = $retainedRoot.Suspend($remaining)",
         "        for ($round = 0; ; $round++) {",
-        "            if ($round -ge 64 -or $held.Count -gt 4096 -or $watch.ElapsedMilliseconds -ge $TimeoutMilliseconds) {",
+        "            if ($round -ge 64 -or $known.Count -gt 4096 -or $watch.ElapsedMilliseconds -ge $TimeoutMilliseconds) {",
         "                throw 'Owned process-tree discovery exceeded its bounded budget; cleanup is incomplete.'",
         "            }",
+        "            $hints = @(& $Snapshot)",
         "            $found = $false",
-        "            foreach ($hint in (& $Snapshot)) {",
-        "                if ($known.ContainsKey([int]$hint.Id) -or !$known.ContainsKey([int]$hint.ParentId)) { continue }",
-        "                if ($watch.ElapsedMilliseconds -ge $TimeoutMilliseconds) { throw 'Owned process-tree discovery timed out; cleanup is incomplete.' }",
-        "                $parent = $known[[int]$hint.ParentId]",
-        "                # Exclude historical PID reuse before opening potentially inaccessible processes.",
-        "                if ($hint.CreationTimeUtcTicks -gt 0 -and $hint.CreationTimeUtcTicks -lt $parent.Process.CreationTimeUtcTicks) { continue }",
-        "                $candidate = & $OpenProcess ([int]$hint.Id)",
-        "                if ($null -eq $candidate) { throw \"Cannot pin candidate process $($hint.Id); cleanup is incomplete.\" }",
-        "                try {",
-        "                    if ($candidate.Id -ne $hint.Id) { throw 'Pinned candidate identity does not match the snapshot.' }",
-        "                    # A snapshot is only a hint; parent and birth must come from the pinned handle.",
-        "                    if ($candidate.ParentId -ne $parent.Process.Id) { continue }",
-        "                    if ($candidate.CreationTimeUtcTicks -lt $parent.Process.CreationTimeUtcTicks) { continue }",
-        "                    if ($candidate.CreationTimeUtcTicks -eq $parent.Process.CreationTimeUtcTicks) {",
-        "                        throw \"Ambiguous parent/child birth ordering for $($candidate.Id); cleanup is incomplete.\"",
+        "            $madeProgress = $true",
+        "            while ($madeProgress) {",
+        "                $madeProgress = $false",
+        "                $hintIndex = 0",
+        "                foreach ($hint in $hints) {",
+        "                    $currentHintIndex = $hintIndex",
+        "                    $hintIndex++",
+        "                    $hintId = [int]$hint.Id",
+        "                    $hintParentId = [int]$hint.ParentId",
+        "                    $hintBirth = [long]$hint.CreationTimeUtcTicks",
+        "                    if ($known.ContainsKey($hintId)) {",
+        "                        $existing = $known[$hintId]",
+        "                        if ($null -eq $existing.Process -and $hintBirth -gt 0 -and $hintBirth -ne $existing.CreationTimeUtcTicks) {",
+        "                            throw \"Vanished process $hintId was reused during discovery; cleanup is incomplete.\"",
+        "                        }",
+        "                        continue",
+        "                    }",
+        "                    if (!$known.ContainsKey($hintParentId)) { continue }",
+        "                    if ($watch.ElapsedMilliseconds -ge $TimeoutMilliseconds) { throw 'Owned process-tree discovery timed out; cleanup is incomplete.' }",
+        "                    $parent = $known[$hintParentId]",
+        "                    if ($null -eq $parent.Process) {",
+        "                        $identity = \"$hintId`:$hintBirth\"",
+        "                        if ($parent.SnapshotGeneration -ne $round -or !$parent.AllowedChildren.ContainsKey($identity)) {",
+        "                            $lineageMessage = \"Cannot prove ownership of process $hintId through vanished parent $hintParentId; cleanup is incomplete.\"",
+        "                            try {",
+        "                                $lineageDiagnostics = New-OwnedWindowsProcessLineageDiagnostics -Known $known -Hints $hints -Parent $parent -Round $round -HintIndex $currentHintIndex -HintId $hintId -HintParentId $hintParentId -HintBirth $hintBirth -Identity $identity",
+        "                                [Console]::Error.WriteLine(\"OWNED_PROCESS_LINEAGE_DIAGNOSTICS $lineageDiagnostics\")",
+        "                                $lineageMessage += \" Ownership diagnostics: $lineageDiagnostics\"",
+        "                            } catch {",
+        "                                $lineageMessage += \" Ownership diagnostic capture failed: $($_.Exception.Message)\"",
+        "                            }",
+        "                            throw $lineageMessage",
+        "                        }",
         "                    }",
-        "                    $parentExit = $parent.Process.ExitTimeUtcTicks",
-        "                    if ($parentExit -ne 0 -and $candidate.CreationTimeUtcTicks -gt $parentExit) { continue }",
-        "                    if ($candidate.Id -eq $PID) { throw 'Refusing to include the cleanup process in the owned tree.' }",
-        "                    # Freeze each accepted parent before its next child snapshot, not an entire discovered tree.",
-        "                    $entry = [PSCustomObject]@{ Process = $candidate; Depth = $parent.Depth + 1 }",
-        "                    $held.Add($entry)",
-        "                    $known[[int]$candidate.Id] = $entry",
+        "                    # Exclude historical PID reuse before opening potentially inaccessible processes.",
+        "                    if ($hintBirth -gt 0 -and $hintBirth -lt $parent.CreationTimeUtcTicks) { continue }",
         "                    $candidate = $null",
-        "                    $entry.Process.Suspend()",
-        "                    $found = $true",
-        "                } finally {",
-        "                    if ($null -ne $candidate) { $candidate.Dispose() }",
+        "                    try {",
+        "                        try { $candidate = & $OpenProcess $hintId }",
+        "                        catch {",
+        "                            $openFailure = $_.Exception",
+        "                            while ($openFailure.InnerException) { $openFailure = $openFailure.InnerException }",
+        "                            $typedAbsent = $openFailure -is [PylanceOwnedWindowsProcess+CandidateOpenException] -and",
+        "                                $openFailure.NativeErrorCode -eq 87 -and $openFailure.ProcessId -eq $hintId",
+        "                            $taggedAbsent = $openFailure -is [System.ComponentModel.Win32Exception] -and",
+        "                                $openFailure.NativeErrorCode -eq 87 -and",
+        "                                $openFailure.Data['PylanceAbsentProcessId'] -eq $hintId",
+        "                            if (!$typedAbsent -and !$taggedAbsent) {",
+        "                                throw",
+        "                            }",
+        "                            if ($hintId -le 0 -or $hintBirth -le 0) {",
+        "                                throw \"Cannot prove the identity of vanished process $hintId; cleanup is incomplete.\"",
+        "                            }",
+        "                            if ($hintBirth -lt $parent.CreationTimeUtcTicks) { continue }",
+        "                            if ($hintBirth -eq $parent.CreationTimeUtcTicks) {",
+        "                                throw \"Ambiguous parent/child birth ordering for $hintId; cleanup is incomplete.\"",
+        "                            }",
+        "                            if ($null -ne $parent.Process) {",
+        "                                $parentExit = $parent.Process.ExitTimeUtcTicks",
+        "                                if ($parentExit -ne 0 -and $hintBirth -gt $parentExit) { continue }",
+        "                            }",
+        "                            if ($hintId -eq $PID) { throw 'Refusing to include the cleanup process in the owned tree.' }",
+        "                            $allowedChildren = @{}",
+        "                            foreach ($childHint in $hints) {",
+        "                                $childId = [int]$childHint.Id",
+        "                                $childBirth = [long]$childHint.CreationTimeUtcTicks",
+        "                                if ([int]$childHint.ParentId -eq $hintId -and $childBirth -gt $hintBirth) {",
+        "                                    $allowedChildren[\"$childId`:$childBirth\"] = $true",
+        "                                }",
+        "                            }",
+        "                            $entry = [PSCustomObject]@{",
+        "                                Process = $null",
+        "                                Id = $hintId",
+        "                                CreationTimeUtcTicks = $hintBirth",
+        "                                Depth = $parent.Depth + 1",
+        "                                ParentId = $hintParentId",
+        "                                SnapshotGeneration = $round",
+        "                                SnapshotIndex = $currentHintIndex",
+        "                                OpenOutcome = 'candidate-open-error-87'",
+        "                                AllowedChildren = $allowedChildren",
+        "                            }",
+        "                            $known[$hintId] = $entry",
+        "                            $found = $true",
+        "                            $madeProgress = $true",
+        "                            continue",
+        "                        }",
+        "                        if ($null -eq $candidate) { throw \"Cannot pin candidate process $hintId; cleanup is incomplete.\" }",
+        "                        if ($candidate.Id -ne $hintId) { throw 'Pinned candidate identity does not match the snapshot.' }",
+        "                        # A pinned identity must match the exact native snapshot generation.",
+        "                        if ($hintBirth -gt 0 -and $candidate.CreationTimeUtcTicks -ne $hintBirth) {",
+        "                            throw \"Pinned candidate birth does not match the snapshot for $hintId; cleanup is incomplete.\"",
+        "                        }",
+        "                        if ($candidate.ParentId -ne $parent.Id) { continue }",
+        "                        if ($candidate.CreationTimeUtcTicks -lt $parent.CreationTimeUtcTicks) { continue }",
+        "                        if ($candidate.CreationTimeUtcTicks -eq $parent.CreationTimeUtcTicks) {",
+        "                            throw \"Ambiguous parent/child birth ordering for $($candidate.Id); cleanup is incomplete.\"",
+        "                        }",
+        "                        if ($null -ne $parent.Process) {",
+        "                            $parentExit = $parent.Process.ExitTimeUtcTicks",
+        "                            if ($parentExit -ne 0 -and $candidate.CreationTimeUtcTicks -gt $parentExit) { continue }",
+        "                        }",
+        "                        if ($candidate.Id -eq $PID) { throw 'Refusing to include the cleanup process in the owned tree.' }",
+        "                        # Freeze each accepted parent before its next child snapshot, not an entire discovered tree.",
+        "                        $entry = [PSCustomObject]@{",
+        "                            Process = $candidate",
+        "                            Id = [int]$candidate.Id",
+        "                            CreationTimeUtcTicks = [long]$candidate.CreationTimeUtcTicks",
+        "                            Depth = $parent.Depth + 1",
+        "                            ParentId = [int]$candidate.ParentId",
+        "                            SnapshotGeneration = -1",
+        "                            SnapshotIndex = $currentHintIndex",
+        "                            OpenOutcome = 'pinned'",
+        "                            AllowedChildren = $null",
+        "                        }",
+        "                        $held.Add($entry)",
+        "                        $known[$hintId] = $entry",
+        "                        $candidate = $null",
+        "                        $remaining = [Math]::Max(1, $TimeoutMilliseconds - [int]$watch.ElapsedMilliseconds)",
+        "                        $null = $entry.Process.Suspend($remaining)",
+        "                        $found = $true",
+        "                        $madeProgress = $true",
+        "                    } finally {",
+        "                        if ($null -ne $candidate) { $candidate.Dispose() }",
+        "                    }",
+        "                }",
+        "            }",
+        "            # Missing candidates require another snapshot, not an assumed empty descendant branch.",
+        "            foreach ($hint in $hints) {",
+        "                if ($missing.ContainsKey([int]$hint.ParentId)) {",
+        "                    throw \"Cannot establish descendant ownership after candidate $($hint.ParentId) disappeared; cleanup is incomplete.\"",
         "                }",
         "            }",
         "            if (!$found) { break }",

package/dist/languageServerBase.d.ts

@@ -43,6 +43,7 @@ export declare abstract class LanguageServerBase implements LanguageServerInterf
     private _workspaceDiagnosticsReporter;
     private _workspaceDiagnosticsProgressReporter;
     private _workspaceDiagnosticsResolve;
+    private _workspaceDiagnosticsCancellationDisposable;
     protected isDisposed: boolean;
     protected client: ClientCapabilities;
     protected defaultClientConfig: any;
@@ -134,9 +135,11 @@ export declare abstract class LanguageServerBase implements LanguageServerInterf
         reporter: WorkDoneProgressReporter;
         source: AbstractCancellationTokenSource;
     }>;
+    protected getWorkspaceDiagnosticVersion(version: number | undefined): number | null;
     protected sendDiagnostics(params: PublishDiagnosticsParams[]): void;
     protected convertLspUriStringToUri(uri: string): Uri;
     protected addDynamicFeature(feature: DynamicFeature): void;
+    private _completeWorkspaceDiagnostics;
     private _getCompatibleMarkupKind;
     private _convertDiagnostics;
 }

package/dist/languageServerBase.js

@@ -233,9 +233,8 @@ class LanguageServerBase {
             this.console.level = serverSettings.logLevel ?? console_1.LogLevel.Info;
             this.dynamicFeatures.update(serverSettings);
             // If the workspace mode has changed, we may need to resolve the workspace diagnostics promise.
-            if (serverSettings.openFilesOnly && this._workspaceDiagnosticsResolve) {
-                this._workspaceDiagnosticsResolve({ items: [] });
-                this._workspaceDiagnosticsResolve = undefined;
+            if (serverSettings.openFilesOnly) {
+                this._completeWorkspaceDiagnostics();
             }
             // Then use the updated settings to restart the service.
             this.updateOptionsAndRestartService(workspace, serverSettings);
@@ -774,9 +773,11 @@ class LanguageServerBase {
         return result;
     }
     async onWorkspaceDiagnostics(params, token, workDoneProgress, resultReporter) {
+        if (token.isCancellationRequested) {
+            return { items: [] };
+        }
         // Resolve any pending workspace diagnostics. We only allow one at a time.
-        this._workspaceDiagnosticsResolve?.({ items: [] });
-        this._workspaceDiagnosticsResolve = undefined;
+        this._completeWorkspaceDiagnostics();
         // Save the progress reporters and force a refresh of analysis.
         this._workspaceDiagnosticsProgressReporter = !(0, lspUtils_1.isNullProgressReporter)(workDoneProgress)
             ? wrapProgressReporter(workDoneProgress)
@@ -785,12 +786,21 @@ class LanguageServerBase {
         this.workspaceFactory.getNonDefaultWorkspaces().forEach((workspace) => {
             workspace.service.invalidateAndScheduleReanalysis(backgroundAnalysisProgram_1.InvalidatedReason.Reanalyzed);
         });
-        return new Promise((resolve, reject) => {
-            // We never resolve as this should be a continually occurring process. Scheduling analysis
-            // should cause a new workspace diagnostic to be generated.
-            // Save the resolve callback to be used during shutdown so that tests don't crash
-            // on the unresolved promise for the workspace diagnostics.
+        return new Promise((resolve) => {
+            // Keep the request active until cancellation, replacement, configuration change, or shutdown.
             this._workspaceDiagnosticsResolve = resolve;
+            const cancellationDisposable = token.onCancellationRequested(() => {
+                this._completeWorkspaceDiagnostics(resolve);
+            });
+            if (this._workspaceDiagnosticsResolve === resolve) {
+                this._workspaceDiagnosticsCancellationDisposable = cancellationDisposable;
+                if (token.isCancellationRequested) {
+                    this._completeWorkspaceDiagnostics(resolve);
+                }
+            }
+            else {
+                cancellationDisposable.dispose();
+            }
         });
     }
     onDidChangeWatchedFiles(params) {
@@ -849,7 +859,7 @@ class LanguageServerBase {
     }
     onShutdown(token) {
         // Shutdown remaining workspaces.
-        this._workspaceDiagnosticsResolve?.({ items: [] });
+        this._completeWorkspaceDiagnostics();
         this.workspaceFactory.clear();
         // Stop tracking all open files.
         this.openFileMap.clear();
@@ -990,6 +1000,9 @@ class LanguageServerBase {
             source: (0, cancellationUtils_1.CancelAfter)(this.serviceProvider.cancellationProvider(), token, serverInitiatedReporter.token),
         };
     }
+    getWorkspaceDiagnosticVersion(version) {
+        return version || null;
+    }
     sendDiagnostics(params) {
         for (const param of params) {
             if (param.diagnostics.length === 0) {
@@ -1002,7 +1015,14 @@ class LanguageServerBase {
             if (this._workspaceDiagnosticsReporter) {
                 // Skip storing previous result ids, just send new results every time.
                 this._workspaceDiagnosticsReporter.report({
-                    items: [{ ...param, kind: 'full', version: param.version || null, items: param.diagnostics }],
+                    items: [
+                        {
+                            ...param,
+                            kind: 'full',
+                            version: this.getWorkspaceDiagnosticVersion(param.version),
+                            items: param.diagnostics,
+                        },
+                    ],
                 });
             }
             else {
@@ -1017,6 +1037,18 @@ class LanguageServerBase {
     addDynamicFeature(feature) {
         this.dynamicFeatures.add(feature);
     }
+    _completeWorkspaceDiagnostics(expectedResolve = this._workspaceDiagnosticsResolve) {
+        if (!expectedResolve || this._workspaceDiagnosticsResolve !== expectedResolve) {
+            return;
+        }
+        this._workspaceDiagnosticsResolve = undefined;
+        this._workspaceDiagnosticsCancellationDisposable?.dispose();
+        this._workspaceDiagnosticsCancellationDisposable = undefined;
+        this._workspaceDiagnosticsReporter = undefined;
+        this._workspaceDiagnosticsProgressReporter?.end();
+        this._workspaceDiagnosticsProgressReporter = undefined;
+        expectedResolve({ items: [] });
+    }
     _getCompatibleMarkupKind(clientSupportedFormats) {
         const serverSupportedFormats = [vscode_languageserver_1.MarkupKind.PlainText, vscode_languageserver_1.MarkupKind.Markdown];
         for (const format of clientSupportedFormats ?? []) {