@codingame/monaco-vscode-api 3.2.3 → 4.0.0

package/vscode/src/vs/workbench/api/common/extHostTesting.js

@@ -6,19 +6,17 @@ import { Emitter, Event } from '../../../base/common/event.js';
 import { createSingleCallFunction } from '../../../base/common/functional.js';
 import { hash } from '../../../base/common/hash.js';
 import { Disposable, toDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
-import { deepFreeze } from '../../../base/common/objects.js';
 import { isDefined } from '../../../base/common/types.js';
 import { generateUuid } from '../../../base/common/uuid.js';
 import { ILogService } from '../../../platform/log/common/log.js';
 import { MainContext } from './extHost.protocol.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
 import { toItemFromContext, ExtHostTestItemCollection, TestItemImpl, TestItemRootImpl } from './extHostTestItem.js';
-import { TestMessage, TestResults, TestTag, location, TestItem, TestCoverage, Range } from './extHostTypeConverters.js';
+import { TestMessage, TestCoverage, TestResults, TestTag, location, TestItem, Range } from './extHostTypeConverters.js';
 import { TestRunProfileKind, TestRunRequest } from './extHostTypes.js';
 import { TestId } from '../../contrib/testing/common/testId.js';
 import { InvalidTestItemError } from '../../contrib/testing/common/testItemCollection.js';
-import { TestsDiffOp, isStartControllerTests, KEEP_N_LAST_COVERAGE_REPORTS, AbstractIncrementalTestCollection } from '../../contrib/testing/common/testTypes.js';
-import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
+import { TestsDiffOp, isStartControllerTests, AbstractIncrementalTestCollection } from '../../contrib/testing/common/testTypes.js';
 let ExtHostTesting = class ExtHostTesting extends Disposable {
     constructor(rpc, logService, commands, editors) {
         super();
@@ -41,9 +39,11 @@ let ExtHostTesting = class ExtHostTesting extends Disposable {
                         return controller?.collection.tree.get(targetTest)?.actual ?? toItemFromContext(arg);
                     }
                     case 18 : {
-                        const { extId, message } = arg;
+                        const { test, message } = arg;
+                        const extId = test.item.extId;
                         return {
-                            test: this.controllers.get(TestId.root(extId))?.collection.tree.get(extId)?.actual,
+                            test: this.controllers.get(TestId.root(extId))?.collection.tree.get(extId)?.actual
+                                ?? toItemFromContext({ $mid: 16 , tests: [test] }),
                             message: TestMessage.to(message),
                         };
                     }
@@ -120,7 +120,7 @@ let ExtHostTesting = class ExtHostTesting extends Disposable {
                 return ( new TestItemImpl(controllerId, id, label, uri));
             },
             createTestRun: (request, name, persist = true) => {
-                return this.runTracker.createTestRun(extension, controllerId, collection, request, name, persist);
+                return this.runTracker.createTestRun(controllerId, collection, request, name, persist);
             },
             invalidateTestResults: items => {
                 if (items === undefined) {
@@ -178,15 +178,12 @@ let ExtHostTesting = class ExtHostTesting extends Disposable {
         }
         return Promise.resolve();
     }
-    async $provideFileCoverage(runId, taskId, token) {
-        const coverage = this.runTracker.getCoverageReport(runId, taskId);
-        const fileCoverage = await coverage?.provideFileCoverage(token);
-        return fileCoverage ?? [];
+    async $getCoverageDetails(coverageId, token) {
+        const details = await this.runTracker.getCoverageDetails(coverageId, token);
+        return details?.map(TestCoverage.fromDetails);
     }
-    async $resolveFileCoverage(runId, taskId, fileIndex, token) {
-        const coverage = this.runTracker.getCoverageReport(runId, taskId);
-        const details = await coverage?.resolveFileCoverage(fileIndex, token);
-        return details ?? [];
+    async $disposeRun(runId) {
+        this.runTracker.disposeTestRun(runId);
     }
     $configureRunProfile(controllerId, profileId) {
         this.controllers.get(controllerId)?.profiles.get(profileId)?.configureHandler?.();
@@ -220,7 +217,7 @@ let ExtHostTesting = class ExtHostTesting extends Disposable {
     }
     $publishTestResults(results) {
         this.results = ( Object.freeze(( results
-            .map(r => deepFreeze(TestResults.to(r))))
+            .map(TestResults.to))
             .concat(this.results)
             .sort((a, b) => b.completedAt - a.completedAt)
             .slice(0, 32)));
@@ -253,7 +250,7 @@ let ExtHostTesting = class ExtHostTesting extends Disposable {
         if (!lookup) {
             return {};
         }
-        const { collection, profiles, extension } = lookup;
+        const { collection, profiles } = lookup;
         const profile = profiles.get(req.profileId);
         if (!profile) {
             return {};
@@ -271,7 +268,7 @@ let ExtHostTesting = class ExtHostTesting extends Disposable {
             return {};
         }
         const publicReq = ( new TestRunRequest(( includeTests.some(i => i.actual instanceof TestItemRootImpl)) ? undefined : ( includeTests.map(t => t.actual)), ( excludeTests.map(t => t.actual)), profile, isContinuous));
-        const tracker = isStartControllerTests(req) && this.runTracker.prepareForMainThreadTestRun(publicReq, TestRunDto.fromInternal(req, lookup.collection), extension, token);
+        const tracker = isStartControllerTests(req) && this.runTracker.prepareForMainThreadTestRun(publicReq, TestRunDto.fromInternal(req, lookup.collection), profile, token);
         try {
             await profile.runHandler(publicReq, token);
             return {};
@@ -284,7 +281,6 @@ let ExtHostTesting = class ExtHostTesting extends Disposable {
                 if (tracker.hasRunningTasks && !token.isCancellationRequested) {
                     await Event.toPromise(tracker.onEnd);
                 }
-                tracker.dispose();
             }
         }
     }
@@ -301,30 +297,36 @@ ExtHostTesting = ( __decorate([
     ( __param(0, IExtHostRpcService)),
     ( __param(1, ILogService))
 ], ExtHostTesting));
-const RUN_CANCEL_DEADLINE = 10000;
+const RUN_CANCEL_DEADLINE = 10_000;
 class TestRunTracker extends Disposable {
     get hasRunningTasks() {
-        return this.tasks.size > 0;
+        return this.running > 0;
     }
     get id() {
         return this.dto.id;
     }
-    constructor(dto, proxy, extension, logService, parentToken) {
+    constructor(dto, proxy, logService, profile, parentToken) {
         super();
         this.dto = dto;
         this.proxy = proxy;
-        this.extension = extension;
         this.logService = logService;
+        this.profile = profile;
         this.state = 0 ;
+        this.running = 0;
         this.tasks = ( new Map());
         this.sharedTestIds = ( new Set());
         this.endEmitter = this._register(( new Emitter()));
-        this.coverageEmitter = this._register(( new Emitter()));
-        this.onDidCoverage = this.coverageEmitter.event;
+        this.publishedCoverage = ( new Map());
         this.onEnd = this.endEmitter.event;
         this.cts = this._register(( new CancellationTokenSource(parentToken)));
         const forciblyEnd = this._register(( new RunOnceScheduler(() => this.forciblyEndTasks(), RUN_CANCEL_DEADLINE)));
         this._register(this.cts.token.onCancellationRequested(() => forciblyEnd.schedule()));
+        const didDisposeEmitter = ( new Emitter());
+        this.onDidDispose = didDisposeEmitter.event;
+        this._register(toDisposable(() => {
+            didDisposeEmitter.fire();
+            didDisposeEmitter.dispose();
+        }));
     }
     cancel() {
         if (this.state === 0 ) {
@@ -335,13 +337,25 @@ class TestRunTracker extends Disposable {
             this.forciblyEndTasks();
         }
     }
+    getCoverageDetails(id, token) {
+        const [, taskId, covId] = TestId.fromString(id).path;
+        const obj = this.publishedCoverage.get(covId);
+        if (!obj) {
+            return [];
+        }
+        if (obj.backCompatResolve) {
+            return obj.backCompatResolve(token);
+        }
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            throw new Error('unreachable: run task was not found');
+        }
+        return this.profile?.loadDetailedCoverage?.(task.run, obj.coverage, token) ?? [];
+    }
     createRun(name) {
         const runId = this.dto.id;
         const ctrlId = this.dto.controllerId;
         const taskId = generateUuid();
-        const extension = this.extension;
-        const coverageEmitter = this.coverageEmitter;
-        let coverage;
         const guardTestMutation = (fn) => (test, ...args) => {
             if (ended) {
                 this.logService.warn(`Setting the state of test "${test.id}" is a no-op after the run ends.`);
@@ -365,19 +379,34 @@ class TestRunTracker extends Disposable {
             }
             this.proxy.$appendTestMessagesInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, ctrlId).toString()), converted);
         };
+        const addCoverage = (coverage, backCompatResolve) => {
+            const uriStr = ( coverage.uri.toString());
+            const id = ( ( new TestId([runId, taskId, uriStr])).toString());
+            this.publishedCoverage.set(uriStr, { coverage, backCompatResolve });
+            this.proxy.$appendCoverage(runId, taskId, TestCoverage.fromFile(id, coverage));
+        };
         let ended = false;
+        let coverageProvider;
         const run = {
             isPersisted: this.dto.isPersisted,
             token: this.cts.token,
             name,
+            onDidDispose: this.onDidDispose,
             get coverageProvider() {
-                return coverage?.provider;
+                return coverageProvider;
             },
             set coverageProvider(provider) {
-                checkProposedApiEnabled(extension, 'testCoverage');
-                coverage = provider && ( new TestRunCoverageBearer(provider));
-                coverageEmitter.fire({ taskId, runId, coverage });
+                coverageProvider = provider;
+                if (provider) {
+                    Promise.resolve(provider.provideFileCoverage(CancellationToken.None)).then(coverage => {
+                        coverage?.forEach(c => addCoverage(c, provider.resolveFileCoverage && (async (token) => {
+                            const r = await provider.resolveFileCoverage(c, token);
+                            return (r || c).detailedCoverage;
+                        })));
+                    });
+                }
             },
+            addCoverage,
             enqueued: guardTestMutation(test => {
                 this.proxy.$updateTestStateInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, ctrlId).toString()), 1 );
             }),
@@ -418,12 +447,12 @@ class TestRunTracker extends Disposable {
                 }
                 ended = true;
                 this.proxy.$finishedTestRunTask(runId, taskId);
-                this.tasks.delete(taskId);
-                if (!this.tasks.size) {
+                if (!--this.running) {
                     this.markEnded();
                 }
             }
         };
+        this.running++;
         this.tasks.set(taskId, { run });
         this.proxy.$startedTestRunTask(runId, { id: taskId, name, running: true });
         return run;
@@ -475,30 +504,33 @@ class TestRunCoordinator {
         this.proxy = proxy;
         this.logService = logService;
         this.tracked = ( new Map());
-        this.coverageReports = [];
-    }
-    getCoverageReport(runId, taskId) {
-        return this.coverageReports
-            .find(r => r.runId === runId)
-            ?.coverage.get(taskId);
+        this.trackedById = ( new Map());
+    }
+    getCoverageDetails(id, token) {
+        const runId = TestId.root(id);
+        return this.trackedById.get(runId)?.getCoverageDetails(id, token) || [];
+    }
+    disposeTestRun(runId) {
+        this.trackedById.get(runId)?.dispose();
+        this.trackedById.delete(runId);
+        for (const [req, { id }] of this.tracked) {
+            if (id === runId) {
+                this.tracked.delete(req);
+            }
+        }
     }
-    prepareForMainThreadTestRun(req, dto, extension, token) {
-        return this.getTracker(req, dto, extension, token);
+    prepareForMainThreadTestRun(req, dto, profile, token) {
+        return this.getTracker(req, dto, profile, token);
     }
     cancelRunById(runId) {
-        for (const tracker of ( this.tracked.values())) {
-            if (tracker.id === runId) {
-                tracker.cancel();
-                return;
-            }
-        }
+        this.trackedById.get(runId)?.cancel();
     }
     cancelAllRuns() {
         for (const tracker of ( this.tracked.values())) {
             tracker.cancel();
         }
     }
-    createTestRun(extension, controllerId, collection, request, name, persist) {
+    createTestRun(controllerId, collection, request, name, persist) {
         const existing = this.tracked.get(request);
         if (existing) {
             return existing.createRun(name);
@@ -514,32 +546,16 @@ class TestRunCoordinator {
             include: request.include?.map(t => ( TestId.fromExtHostTestItem(t, collection.root.id).toString())) ?? [collection.root.id],
             persist
         });
-        const tracker = this.getTracker(request, dto, extension);
+        const tracker = this.getTracker(request, dto, request.profile);
         Event.once(tracker.onEnd)(() => {
             this.proxy.$finishedExtensionTestRun(dto.id);
-            tracker.dispose();
         });
         return tracker.createRun(name);
     }
-    getTracker(req, dto, extension, token) {
-        const tracker = ( new TestRunTracker(dto, this.proxy, extension, this.logService, token));
+    getTracker(req, dto, profile, token) {
+        const tracker = ( new TestRunTracker(dto, this.proxy, this.logService, profile, token));
         this.tracked.set(req, tracker);
-        let coverageReports;
-        const coverageListener = tracker.onDidCoverage(({ runId, taskId, coverage }) => {
-            if (!coverageReports) {
-                coverageReports = { runId, coverage: ( new Map()) };
-                this.coverageReports.unshift(coverageReports);
-                if (this.coverageReports.length > KEEP_N_LAST_COVERAGE_REPORTS) {
-                    this.coverageReports.pop();
-                }
-            }
-            coverageReports.coverage.set(taskId, coverage);
-            this.proxy.$signalCoverageAvailable(runId, taskId, !!coverage);
-        });
-        Event.once(tracker.onEnd)(() => {
-            this.tracked.delete(req);
-            coverageListener.dispose();
-        });
+        this.trackedById.set(tracker.id, tracker);
         return tracker;
     }
 }
@@ -589,35 +605,6 @@ class TestRunDto {
         return false;
     }
 }
-class TestRunCoverageBearer {
-    constructor(provider) {
-        this.provider = provider;
-    }
-    async provideFileCoverage(token) {
-        if (!this.fileCoverage) {
-            this.fileCoverage = (async () => this.provider.provideFileCoverage(token))();
-        }
-        try {
-            const coverage = await this.fileCoverage;
-            return coverage?.map(TestCoverage.fromFile) ?? [];
-        }
-        catch (e) {
-            this.fileCoverage = undefined;
-            throw e;
-        }
-    }
-    async resolveFileCoverage(index, token) {
-        const fileCoverage = await this.fileCoverage;
-        let file = fileCoverage?.[index];
-        if (!this.provider || !fileCoverage || !file) {
-            return [];
-        }
-        if (!file.detailedCoverage) {
-            file = fileCoverage[index] = (await this.provider.resolveFileCoverage?.(file, token)) ?? file;
-        }
-        return file.detailedCoverage?.map(TestCoverage.fromDetailed) ?? [];
-    }
-}
 class MirroredChangeCollector {
     get isEmpty() {
         return this.added.size === 0 && this.removed.size === 0 && this.updated.size === 0;

package/vscode/src/vs/workbench/api/common/extHostTimeline.js

@@ -1,4 +1,5 @@
 import { URI } from '../../../base/common/uri.js';
+import '../../../platform/instantiation/common/instantiation.js';
 import { MainContext } from './extHost.protocol.js';
 import { toDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
 import { ThemeIcon, MarkdownString } from './extHostTypes.js';

package/vscode/src/vs/workbench/api/common/extHostTunnelService.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { CancellationTokenSource } from '../../../base/common/cancellation.js';
+import { CancellationToken } from '../../../base/common/cancellation.js';
 import { Emitter } from '../../../base/common/event.js';
 import { Disposable, toDisposable } from '../../../base/common/lifecycle.js';
 import { localizeWithPath } from '../../../nls.js';
@@ -70,6 +70,9 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
         return this._providerHandleCounter++;
     }
     registerPortsAttributesProvider(portSelector, provider) {
+        if (portSelector.portRange === undefined && portSelector.commandPattern === undefined) {
+            this.logService.error('PortAttributesProvider must specify either a portRange or a commandPattern');
+        }
         const providerHandle = this.nextPortAttributesProviderHandle();
         this._portAttributesProviders.set(providerHandle, { selector: portSelector, provider });
         this._proxy.$registerPortsAttributesProvider(portSelector, providerHandle);
@@ -110,7 +113,7 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
             throw new Error('A tunnel provider has already been registered. Only the first tunnel provider to be registered will be used.');
         }
         this._forwardPortProvider = async (tunnelOptions, tunnelCreationOptions) => {
-            const result = await provider.provideTunnel(tunnelOptions, tunnelCreationOptions, ( new CancellationTokenSource()).token);
+            const result = await provider.provideTunnel(tunnelOptions, tunnelCreationOptions, CancellationToken.None);
             return result ?? undefined;
         };
         const tunnelFeatures = information.tunnelFeatures ? {