@codingame/monaco-vscode-api 5.2.0 → 6.0.0

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

@@ -6,6 +6,7 @@ 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 { MarshalledId } from '../../../base/common/marshallingIds.js';
 import { isDefined } from '../../../base/common/types.js';
 import { generateUuid } from '../../../base/common/uuid.js';
 import { ILogService } from '../../../platform/log/common/log.service.js';
@@ -13,17 +14,25 @@ import { MainContext } from './extHost.protocol.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
 import { toItemFromContext, ExtHostTestItemCollection, TestItemImpl, TestItemRootImpl } from './extHostTestItem.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 { TestRunProfileKind, TestRunRequest, FileCoverage } from './extHostTypes.js';
+import { TestCommandId } from '../../contrib/testing/common/constants.js';
+import { TestId, TestPosition, TestIdPathParts } from '../../contrib/testing/common/testId.js';
 import { InvalidTestItemError } from '../../contrib/testing/common/testItemCollection.js';
-import { TestsDiffOp, isStartControllerTests, AbstractIncrementalTestCollection } from '../../contrib/testing/common/testTypes.js';
+import { TestsDiffOp, isStartControllerTests, TestRunProfileBitset, AbstractIncrementalTestCollection, TestResultState } from '../../contrib/testing/common/testTypes.js';
+import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
+let followupCounter = 0;
+const testResultInternalIDs = ( new WeakMap());
 let ExtHostTesting = class ExtHostTesting extends Disposable {
     constructor(rpc, logService, commands, editors) {
         super();
+        this.logService = logService;
+        this.commands = commands;
         this.editors = editors;
         this.resultsChangedEmitter = this._register(( new Emitter()));
         this.controllers = ( new Map());
         this.defaultProfilesChangedEmitter = this._register(( new Emitter()));
+        this.followupProviders = ( new Set());
+        this.testFollowups = ( new Map());
         this.onResultsChanged = this.resultsChangedEmitter.event;
         this.results = [];
         this.proxy = ( rpc.getProxy(MainContext.MainThreadTesting));
@@ -32,18 +41,18 @@ let ExtHostTesting = class ExtHostTesting extends Disposable {
         commands.registerArgumentProcessor({
             processArgument: arg => {
                 switch (arg?.$mid) {
-                    case 16 : {
+                    case MarshalledId.TestItemContext: {
                         const cast = arg;
                         const targetTest = cast.tests[cast.tests.length - 1].item.extId;
                         const controller = this.controllers.get(TestId.root(targetTest));
                         return controller?.collection.tree.get(targetTest)?.actual ?? toItemFromContext(arg);
                     }
-                    case 18 : {
+                    case MarshalledId.TestMessageMenuArgs: {
                         const { test, message } = arg;
                         const extId = test.item.extId;
                         return {
                             test: this.controllers.get(TestId.root(extId))?.collection.tree.get(extId)?.actual
-                                ?? toItemFromContext({ $mid: 16 , tests: [test] }),
+                                ?? toItemFromContext({ $mid: MarshalledId.TestItemContext, tests: [test] }),
                             message: TestMessage.to(message),
                         };
                     }
@@ -52,7 +61,7 @@ let ExtHostTesting = class ExtHostTesting extends Disposable {
             }
         });
         commands.registerCommand(false, 'testing.getExplorerSelection', async () => {
-            const inner = await commands.executeCommand("_testing.getExplorerSelection" );
+            const inner = await commands.executeCommand(TestCommandId.GetExplorerSelection);
             const lookup = (i) => {
                 const controller = this.controllers.get(TestId.root(i));
                 if (!controller) {
@@ -120,7 +129,7 @@ let ExtHostTesting = class ExtHostTesting extends Disposable {
                 return ( new TestItemImpl(controllerId, id, label, uri));
             },
             createTestRun: (request, name, persist = true) => {
-                return this.runTracker.createTestRun(controllerId, collection, request, name, persist);
+                return this.runTracker.createTestRun(extension, controllerId, collection, request, name, persist);
             },
             invalidateTestResults: items => {
                 if (items === undefined) {
@@ -172,6 +181,10 @@ let ExtHostTesting = class ExtHostTesting extends Disposable {
             exclude: req.exclude?.map(t => t.id),
         }, token);
     }
+    registerTestFollowupProvider(provider) {
+        this.followupProviders.add(provider);
+        return { dispose: () => { this.followupProviders.delete(provider); } };
+    }
     $syncTests() {
         for (const { collection } of ( this.controllers.values())) {
             collection.flushDiff();
@@ -217,7 +230,11 @@ let ExtHostTesting = class ExtHostTesting extends Disposable {
     }
     $publishTestResults(results) {
         this.results = ( Object.freeze(( results
-            .map(TestResults.to))
+            .map(r => {
+            const o = TestResults.to(r);
+            testResultInternalIDs.set(o, r.id);
+            return o;
+        }))
             .concat(this.results)
             .sort((a, b) => b.completedAt - a.completedAt)
             .slice(0, 32)));
@@ -245,12 +262,51 @@ let ExtHostTesting = class ExtHostTesting extends Disposable {
         cts.dispose(true);
         return res;
     }
+    async $provideTestFollowups(req, token) {
+        const results = this.results.find(r => testResultInternalIDs.get(r) === req.resultId);
+        const test = results && findTestInResultSnapshot(TestId.fromString(req.extId), results?.results);
+        if (!test) {
+            return [];
+        }
+        let followups = [];
+        await Promise.all(( [...this.followupProviders].map(async (provider) => {
+            try {
+                const r = await provider.provideFollowup(results, test, req.taskIndex, req.messageIndex, token);
+                if (r) {
+                    followups = followups.concat(r);
+                }
+            }
+            catch (e) {
+                this.logService.error(`Error thrown while providing followup for test message`, e);
+            }
+        })));
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        return ( followups.map(command => {
+            const id = followupCounter++;
+            this.testFollowups.set(id, command);
+            return { title: command.title, id };
+        }));
+    }
+    $disposeTestFollowups(id) {
+        for (const i of id) {
+            this.testFollowups.delete(i);
+        }
+    }
+    $executeTestFollowup(id) {
+        const command = this.testFollowups.get(id);
+        if (!command) {
+            return Promise.resolve();
+        }
+        return this.commands.executeCommand(command.command, ...(command.arguments || []));
+    }
     async runControllerTestRequest(req, isContinuous, token) {
         const lookup = this.controllers.get(req.controllerId);
         if (!lookup) {
             return {};
         }
-        const { collection, profiles } = lookup;
+        const { collection, profiles, extension } = lookup;
         const profile = profiles.get(req.profileId);
         if (!profile) {
             return {};
@@ -261,14 +317,12 @@ let ExtHostTesting = class ExtHostTesting extends Disposable {
         const excludeTests = ( req.excludeExtIds
             .map(id => lookup.collection.tree.get(id)))
             .filter(isDefined)
-            .filter(exclude => ( includeTests.some(
-            include => include.fullId.compare(exclude.fullId) === 2
-        )));
+            .filter(exclude => ( includeTests.some(include => include.fullId.compare(exclude.fullId) === TestPosition.IsChild)));
         if (!includeTests.length) {
             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), profile, token);
+        const tracker = isStartControllerTests(req) && this.runTracker.prepareForMainThreadTestRun(extension, publicReq, TestRunDto.fromInternal(req, lookup.collection), profile, token);
         try {
             await profile.runHandler(publicReq, token);
             return {};
@@ -298,6 +352,12 @@ ExtHostTesting = ( __decorate([
     ( __param(1, ILogService))
 ], ExtHostTesting));
 const RUN_CANCEL_DEADLINE = 10_000;
+var TestRunTrackerState;
+( (function(TestRunTrackerState) {
+    TestRunTrackerState[TestRunTrackerState["Running"] = 0] = "Running";
+    TestRunTrackerState[TestRunTrackerState["Cancelling"] = 1] = "Cancelling";
+    TestRunTrackerState[TestRunTrackerState["Ended"] = 2] = "Ended";
+})(TestRunTrackerState || (TestRunTrackerState = {})));
 class TestRunTracker extends Disposable {
     get hasRunningTasks() {
         return this.running > 0;
@@ -305,13 +365,14 @@ class TestRunTracker extends Disposable {
     get id() {
         return this.dto.id;
     }
-    constructor(dto, proxy, logService, profile, parentToken) {
+    constructor(dto, proxy, logService, profile, extension, parentToken) {
         super();
         this.dto = dto;
         this.proxy = proxy;
         this.logService = logService;
         this.profile = profile;
-        this.state = 0 ;
+        this.extension = extension;
+        this.state = TestRunTrackerState.Running;
         this.running = 0;
         this.tasks = ( new Map());
         this.sharedTestIds = ( new Set());
@@ -329,17 +390,17 @@ class TestRunTracker extends Disposable {
         }));
     }
     cancel() {
-        if (this.state === 0 ) {
+        if (this.state === TestRunTrackerState.Running) {
             this.cts.cancel();
-            this.state = 1 ;
+            this.state = TestRunTrackerState.Cancelling;
         }
-        else if (this.state === 1 ) {
+        else if (this.state === TestRunTrackerState.Cancelling) {
             this.forciblyEndTasks();
         }
     }
     getCoverageDetails(id, token) {
-        const [, taskId, covId] = TestId.fromString(id).path;
-        const coverage = this.publishedCoverage.get(covId);
+        const [, taskId] = TestId.fromString(id).path;
+        const coverage = this.publishedCoverage.get(id);
         if (!coverage) {
             return [];
         }
@@ -377,36 +438,56 @@ class TestRunTracker extends Disposable {
             this.proxy.$appendTestMessagesInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, ctrlId).toString()), converted);
         };
         let ended = false;
+        const testItemCoverageId = ( new Map());
         const run = {
             isPersisted: this.dto.isPersisted,
             token: this.cts.token,
             name,
             onDidDispose: this.onDidDispose,
-            addCoverage: coverage => {
+            addCoverage: (coverage) => {
+                if (ended) {
+                    return;
+                }
+                const testItem = coverage instanceof FileCoverage ? coverage.testItem : undefined;
+                let testItemIdPart;
+                if (testItem) {
+                    checkProposedApiEnabled(this.extension, 'attributableCoverage');
+                    if (!this.dto.isIncluded(testItem)) {
+                        throw ( new Error('Attempted to `addCoverage` for a test item not included in the run'));
+                    }
+                    this.ensureTestIsKnown(testItem);
+                    testItemIdPart = testItemCoverageId.get(testItem);
+                    if (testItemIdPart === undefined) {
+                        testItemIdPart = testItemCoverageId.size;
+                        testItemCoverageId.set(testItem, testItemIdPart);
+                    }
+                }
                 const uriStr = ( coverage.uri.toString());
-                const id = ( ( new TestId([runId, taskId, uriStr])).toString());
-                this.publishedCoverage.set(uriStr, coverage);
-                this.proxy.$appendCoverage(runId, taskId, TestCoverage.fromFile(id, coverage));
+                const id = ( ( new TestId(testItemIdPart !== undefined
+                    ? [runId, taskId, uriStr, String(testItemIdPart)]
+                    : [runId, taskId, uriStr])).toString());
+                this.publishedCoverage.set(id, coverage);
+                this.proxy.$appendCoverage(runId, taskId, TestCoverage.fromFile(ctrlId, id, coverage));
             },
             enqueued: guardTestMutation(test => {
-                this.proxy.$updateTestStateInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, ctrlId).toString()), 1 );
+                this.proxy.$updateTestStateInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, ctrlId).toString()), TestResultState.Queued);
             }),
             skipped: guardTestMutation(test => {
-                this.proxy.$updateTestStateInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, ctrlId).toString()), 5 );
+                this.proxy.$updateTestStateInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, ctrlId).toString()), TestResultState.Skipped);
             }),
             started: guardTestMutation(test => {
-                this.proxy.$updateTestStateInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, ctrlId).toString()), 2 );
+                this.proxy.$updateTestStateInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, ctrlId).toString()), TestResultState.Running);
             }),
             errored: guardTestMutation((test, messages, duration) => {
                 appendMessages(test, messages);
-                this.proxy.$updateTestStateInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, ctrlId).toString()), 6 , duration);
+                this.proxy.$updateTestStateInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, ctrlId).toString()), TestResultState.Errored, duration);
             }),
             failed: guardTestMutation((test, messages, duration) => {
                 appendMessages(test, messages);
-                this.proxy.$updateTestStateInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, ctrlId).toString()), 4 , duration);
+                this.proxy.$updateTestStateInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, ctrlId).toString()), TestResultState.Failed, duration);
             }),
             passed: guardTestMutation((test, duration) => {
-                this.proxy.$updateTestStateInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, this.dto.controllerId).toString()), 3 , duration);
+                this.proxy.$updateTestStateInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, this.dto.controllerId).toString()), TestResultState.Passed, duration);
             }),
             appendOutput: (output, location$1, test) => {
                 if (ended) {
@@ -427,6 +508,7 @@ class TestRunTracker extends Disposable {
                     return;
                 }
                 ended = true;
+                testItemCoverageId.clear();
                 this.proxy.$finishedTestRunTask(runId, taskId);
                 if (!--this.running) {
                     this.markEnded();
@@ -444,8 +526,8 @@ class TestRunTracker extends Disposable {
         }
     }
     markEnded() {
-        if (this.state !== 2 ) {
-            this.state = 2 ;
+        if (this.state !== TestRunTrackerState.Ended) {
+            this.state = TestRunTrackerState.Ended;
             this.endEmitter.fire();
         }
     }
@@ -500,8 +582,8 @@ class TestRunCoordinator {
             }
         }
     }
-    prepareForMainThreadTestRun(req, dto, profile, token) {
-        return this.getTracker(req, dto, profile, token);
+    prepareForMainThreadTestRun(extension, req, dto, profile, token) {
+        return this.getTracker(req, dto, profile, extension, token);
     }
     cancelRunById(runId) {
         this.trackedById.get(runId)?.cancel();
@@ -511,7 +593,7 @@ class TestRunCoordinator {
             tracker.cancel();
         }
     }
-    createTestRun(controllerId, collection, request, name, persist) {
+    createTestRun(extension, controllerId, collection, request, name, persist) {
         const existing = this.tracked.get(request);
         if (existing) {
             return existing.createRun(name);
@@ -528,14 +610,14 @@ class TestRunCoordinator {
             preserveFocus: request.preserveFocus ?? true,
             persist
         });
-        const tracker = this.getTracker(request, dto, request.profile);
+        const tracker = this.getTracker(request, dto, request.profile, extension);
         Event.once(tracker.onEnd)(() => {
             this.proxy.$finishedExtensionTestRun(dto.id);
         });
         return tracker.createRun(name);
     }
-    getTracker(req, dto, profile, token) {
-        const tracker = ( new TestRunTracker(dto, this.proxy, this.logService, profile, token));
+    getTracker(req, dto, profile, extension, token) {
+        const tracker = ( new TestRunTracker(dto, this.proxy, this.logService, profile, extension, token));
         this.tracked.set(req, tracker);
         this.trackedById.set(tracker.id, tracker);
         return tracker;
@@ -571,11 +653,11 @@ class TestRunDto {
         this.id = id;
         this.isPersisted = isPersisted;
         this.colllection = colllection;
-        this.includePrefix = ( include.map(id => id + "\0" ));
-        this.excludePrefix = ( exclude.map(id => id + "\0" ));
+        this.includePrefix = ( include.map(id => id + TestIdPathParts.Delimiter));
+        this.excludePrefix = ( exclude.map(id => id + TestIdPathParts.Delimiter));
     }
     isIncluded(test) {
-        const id = ( TestId.fromExtHostTestItem(test, this.controllerId).toString()) + "\0" ;
+        const id = ( TestId.fromExtHostTestItem(test, this.controllerId).toString()) + TestIdPathParts.Delimiter;
         for (const prefix of this.excludePrefix) {
             if (id === prefix || id.startsWith(prefix)) {
                 return false;
@@ -813,8 +895,21 @@ class TestRunProfileImpl {
     }
 }
 const profileGroupToBitset = {
-    [TestRunProfileKind.Coverage]: 8 ,
-    [TestRunProfileKind.Debug]: 4 ,
-    [TestRunProfileKind.Run]: 2 ,
+    [TestRunProfileKind.Coverage]: TestRunProfileBitset.Coverage,
+    [TestRunProfileKind.Debug]: TestRunProfileBitset.Debug,
+    [TestRunProfileKind.Run]: TestRunProfileBitset.Run,
 };
+function findTestInResultSnapshot(extId, snapshot) {
+    for (let i = 0; i < extId.path.length; i++) {
+        const item = snapshot.find(s => s.id === extId.path[i]);
+        if (!item) {
+            return undefined;
+        }
+        if (i === extId.path.length - 1) {
+            return item;
+        }
+        snapshot = item.children;
+    }
+    return undefined;
+}
 export { ExtHostTesting, TestRunCoordinator, TestRunDto, TestRunProfileImpl };

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

@@ -5,6 +5,7 @@ import { toDisposable, DisposableStore } from '../../../base/common/lifecycle.js
 import { ThemeIcon, MarkdownString } from './extHostTypes.js';
 import { MarkdownString as MarkdownString$1 } from './extHostTypeConverters.js';
 import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
+import { MarshalledId } from '../../../base/common/marshallingIds.js';
 import { isString } from '../../../base/common/types.js';
 class ExtHostTimeline {
     constructor(mainContext, commands) {
@@ -13,7 +14,7 @@ class ExtHostTimeline {
         this._proxy = ( mainContext.getProxy(MainContext.MainThreadTimeline));
         commands.registerArgumentProcessor({
             processArgument: (arg, extension) => {
-                if (arg && arg.$mid === 12 ) {
+                if (arg && arg.$mid === MarshalledId.TimelineActionContext) {
                     if (this._providers.get(arg.source) && ExtensionIdentifier.equals(extension, this._providers.get(arg.source)?.extension)) {
                         const uri = arg.uri === undefined ? undefined : URI.revive(arg.uri);
                         return this._itemsBySourceAndUriMap.get(arg.source)?.get(getUriKey(uri))?.get(arg.handle);