add generic marker sequence and markers/decorations for problems

src/vs/platform/terminal/common/capabilities/capabilities.ts

@@ -5,6 +5,9 @@
 
 import { Event } from 'vs/base/common/event';
 import { IGenericMarkProperties, ISerializedCommandDetectionCapability } from 'vs/platform/terminal/common/terminalProcess';
+// Importing types is safe in any layer
+// eslint-disable-next-line code-import-patterns
+import type { IMarker } from 'xterm-headless';
 
 /**
  * Primarily driven by the shell integration feature, a terminal capability is the mechanism for
@@ -117,9 +120,9 @@ export interface ICommandDetectionCapability {
 	handleRightPromptStart(): void;
 	handleRightPromptEnd(): void;
 	handleCommandStart(): void;
-	handleGenericCommand(properties: IGenericMarkProperties): void;
+	handleGenericCommand(marker: IMarker | undefined, properties: IGenericMarkProperties): void;
 	handleCommandExecuted(): void;
-	handleCommandFinished(exitCode: number | undefined, genericMarkProperties?: IGenericMarkProperties): void;
+	handleCommandFinished(exitCode: number | undefined, marker?: IMarker, genericMarkProperties?: IGenericMarkProperties): void;
 	invalidateCurrentCommand(request: ICommandInvalidationRequest): void;
 	/**
 	 * Set the command line explicitly.

src/vs/platform/terminal/common/capabilities/commandDetectionCapability.ts

@@ -264,8 +264,8 @@ export class CommandDetectionCapability implements ICommandDetectionCapability {
 		return reversed.find(c => c.marker!.line <= line - 1)?.cwd;
 	}
 
-	handlePromptStart(): void {
-		this._currentCommand.promptStartMarker = this._terminal.registerMarker(0);
+	handlePromptStart(marker?: IMarker): void {
+		this._currentCommand.promptStartMarker = marker || this._terminal.registerMarker(0);
 		this._logService.debug('CommandDetectionCapability#handlePromptStart', this._terminal.buffer.active.cursorX, this._currentCommand.promptStartMarker?.line);
 	}
 
@@ -300,8 +300,9 @@ export class CommandDetectionCapability implements ICommandDetectionCapability {
 		this._logService.debug('CommandDetectionCapability#handleRightPromptEnd', this._currentCommand.commandRightPromptEndX);
 	}
 
-	handleCommandStart(genericMarkProperties?: IGenericMarkProperties): void {
+	handleCommandStart(marker?: IMarker, genericMarkProperties?: IGenericMarkProperties): void {
 		// Only update the column if the line has already been set
+		this._currentCommand.commandStartMarker = marker || this._currentCommand.commandStartMarker;
 		if (this._currentCommand.commandStartMarker?.line === this._terminal.buffer.active.cursorY) {
 			this._currentCommand.commandStartX = this._terminal.buffer.active.cursorX;
 			this._logService.debug('CommandDetectionCapability#handleCommandStart', this._currentCommand.commandStartX, this._currentCommand.commandStartMarker?.line);
@@ -312,8 +313,8 @@ export class CommandDetectionCapability implements ICommandDetectionCapability {
 			return;
 		}
 		this._currentCommand.commandStartX = this._terminal.buffer.active.cursorX;
-		this._currentCommand.commandStartMarker = this._terminal.registerMarker(0);
-		this._onCommandStarted.fire({ marker: this._currentCommand.commandStartMarker, genericMarkProperties } as ITerminalCommand);
+		this._currentCommand.commandStartMarker = marker || this._terminal.registerMarker(0);
+		this._onCommandStarted.fire({ marker: marker || this._currentCommand.commandStartMarker, genericMarkProperties } as ITerminalCommand);
 		this._logService.debug('CommandDetectionCapability#handleCommandStart', this._currentCommand.commandStartX, this._currentCommand.commandStartMarker?.line);
 	}
 
@@ -348,23 +349,23 @@ export class CommandDetectionCapability implements ICommandDetectionCapability {
 		});
 	}
 
-	handleGenericCommand(properties: IGenericMarkProperties): void {
+	handleGenericCommand(marker: IMarker, properties: IGenericMarkProperties): void {
 		if (properties.disableCommandStorage) {
 			this.setIsCommandStorageDisabled();
 		}
-		this.handlePromptStart();
-		this.handleCommandStart(properties);
-		this.handleCommandExecuted();
-		this.handleCommandFinished(undefined, properties);
+		this.handlePromptStart(marker);
+		this.handleCommandStart(marker, properties);
+		this.handleCommandExecuted(marker);
+		this.handleCommandFinished(undefined, marker, properties);
 	}
 
-	handleCommandExecuted(): void {
+	handleCommandExecuted(marker?: IMarker): void {
 		if (this._isWindowsPty) {
 			this._handleCommandExecutedWindows();
 			return;
 		}
 
-		this._currentCommand.commandExecutedMarker = this._terminal.registerMarker(0);
+		this._currentCommand.commandExecutedMarker = marker || this._terminal.registerMarker(0);
 		this._currentCommand.commandExecutedX = this._terminal.buffer.active.cursorX;
 		this._logService.debug('CommandDetectionCapability#handleCommandExecuted', this._currentCommand.commandExecutedX, this._currentCommand.commandExecutedMarker?.line);
 
@@ -408,12 +409,12 @@ export class CommandDetectionCapability implements ICommandDetectionCapability {
 		this._onCurrentCommandInvalidated.fire(request);
 	}
 
-	handleCommandFinished(exitCode: number | undefined, genericMarkProperties?: IGenericMarkProperties): void {
+	handleCommandFinished(exitCode: number | undefined, marker?: IMarker, genericMarkProperties?: IGenericMarkProperties): void {
 		if (this._isWindowsPty) {
 			this._preHandleCommandFinishedWindows();
 		}
 
-		this._currentCommand.commandFinishedMarker = this._terminal.registerMarker(0);
+		this._currentCommand.commandFinishedMarker = marker || this._terminal.registerMarker(0);
 		const command = this._currentCommand.command;
 		this._logService.debug('CommandDetectionCapability#handleCommandFinished', this._terminal.buffer.active.cursorX, this._currentCommand.commandFinishedMarker?.line, this._currentCommand.command, this._currentCommand);
 		this._exitCode = exitCode;

src/vs/platform/terminal/common/xterm/shellIntegrationAddon.ts

@@ -268,7 +268,7 @@ export class ShellIntegrationAddon extends Disposable implements IShellIntegrati
 		const [command, hoverMessage, disableCommandStorage] = data.split(';');
 		switch (command) {
 			case ITermOscPt.SetMark: {
-				this._createOrGetCommandDetection(this._terminal).handleGenericCommand({ hoverMessage: hoverMessage || '', disableCommandStorage: disableCommandStorage === 'true' ? true : false });
+				this._createOrGetCommandDetection(this._terminal).handleGenericCommand(undefined, { hoverMessage: hoverMessage || '', disableCommandStorage: disableCommandStorage === 'true' ? true : false });
 			}
 		}
 

src/vs/workbench/contrib/tasks/browser/taskTerminalStatus.ts

@@ -14,7 +14,6 @@ import { ITerminalInstance } from 'vs/workbench/contrib/terminal/browser/termina
 import { ITerminalStatus } from 'vs/workbench/contrib/terminal/browser/terminalStatusList';
 import { MarkerSeverity } from 'vs/platform/markers/common/markers';
 import { spinningLoading } from 'vs/platform/theme/common/iconRegistry';
-import { CommandInvalidationReason, TerminalCapability } from 'vs/platform/terminal/common/capabilities/capabilities';
 
 interface ITerminalData {
 	terminal: ITerminalInstance;
@@ -54,8 +53,8 @@ export class TaskTerminalStatus extends Disposable {
 	addTerminal(task: Task, terminal: ITerminalInstance, problemMatcher: AbstractProblemCollector) {
 		const status: ITerminalStatus = { id: TASK_TERMINAL_STATUS_ID, severity: Severity.Info };
 		terminal.statusList.add(status);
-		problemMatcher.onDidFindMatch(() => terminal.addGenericMarker({ hoverMessage: nls.localize('task.watchFirstError', "First error"), disableCommandStorage: true }));
-		problemMatcher.onDidInvalidateMatch(() => terminal.capabilities.get(TerminalCapability.CommandDetection)?.invalidateCurrentCommand({ reason: CommandInvalidationReason.NoProblemsReported }));
+		problemMatcher.onDidFindFirstMatch(() => terminal.addGenericMarker());
+		problemMatcher.onDidFindErrors(() => terminal.addDecoration({ hoverMessage: nls.localize('task.watchFirstError', "First error"), disableCommandStorage: true }));
 		this.terminalMap.set(task._id, { terminal, task, status, problemMatcher, taskRunEnded: false });
 	}
 

src/vs/workbench/contrib/tasks/common/problemCollectors.ts

@@ -58,11 +58,11 @@ export abstract class AbstractProblemCollector implements IDisposable {
 
 	protected _onDidStateChange: Emitter<IProblemCollectorEvent>;
 
-	protected readonly _onDidFindMatch = new Emitter<void>();
-	readonly onDidFindMatch = this._onDidFindMatch.event;
+	protected readonly _onDidFindFirstMatch = new Emitter<void>();
+	readonly onDidFindFirstMatch = this._onDidFindFirstMatch.event;
 
-	protected readonly _onDidInvalidateMatch = new Emitter<void>();
-	readonly onDidInvalidateMatch = this._onDidInvalidateMatch.event;
+	protected readonly _onDidFindErrors = new Emitter<void>();
+	readonly onDidFindErrors = this._onDidFindErrors.event;
 
 	constructor(public readonly problemMatchers: ProblemMatcher[], protected markerService: IMarkerService, protected modelService: IModelService, fileService?: IFileService) {
 		this.matchers = Object.create(null);
@@ -498,7 +498,7 @@ export class WatchingProblemCollector extends AbstractProblemCollector implement
 				}
 				this._activeBackgroundMatchers.add(background.key);
 				result = true;
-				this._onDidFindMatch.fire();
+				this._onDidFindFirstMatch.fire();
 				this.lines = [];
 				this.lines.push(line);
 				this._onDidStateChange.fire(IProblemCollectorEvent.create(ProblemCollectorEventKind.BackgroundProcessingBegins));
@@ -522,8 +522,8 @@ export class WatchingProblemCollector extends AbstractProblemCollector implement
 		for (const background of this.backgroundPatterns) {
 			const matches = background.end.regexp.exec(line);
 			if (matches) {
-				if (this._numberOfMatches === 0) {
-					this._onDidInvalidateMatch.fire();
+				if (this._numberOfMatches > 0) {
+					this._onDidFindErrors.fire();
 				}
 				if (this._activeBackgroundMatchers.has(background.key)) {
 					this._activeBackgroundMatchers.delete(background.key);

src/vs/workbench/contrib/tasks/test/browser/taskTerminalStatus.test.ts

@@ -39,7 +39,7 @@ class TestTask extends CommonTask {
 
 class TestProblemCollector implements Partial<AbstractProblemCollector> {
 	private readonly _onDidFindMatch = new Emitter<void>();
-	readonly onDidFindMatch = this._onDidFindMatch.event;
+	readonly onDidFindFirstMatch = this._onDidFindMatch.event;
 	private readonly _onDidInvalidateMatch = new Emitter<void>();
 	readonly onDidInvalidateMatch = this._onDidInvalidateMatch.event;
 }

src/vs/workbench/contrib/terminal/browser/terminal.ts

@@ -19,6 +19,7 @@ import { IEditableData } from 'vs/workbench/common/views';
 import { ITerminalStatusList } from 'vs/workbench/contrib/terminal/browser/terminalStatusList';
 import { INavigationMode, IRegisterContributedProfileArgs, IRemoteTerminalAttachTarget, IStartExtensionTerminalRequest, ITerminalBackend, ITerminalConfigHelper, ITerminalFont, ITerminalProcessExtHostProxy } from 'vs/workbench/contrib/terminal/common/terminal';
 import { EditorGroupColumn } from 'vs/workbench/services/editor/common/editorGroupColumn';
+import { IMarker } from 'xterm';
 
 export const ITerminalService = createDecorator<ITerminalService>('terminalService');
 export const ITerminalEditorService = createDecorator<ITerminalEditorService>('terminalEditorService');
@@ -637,9 +638,15 @@ export interface ITerminalInstance {
 	showEnvironmentInfoHover(): void;
 
 	/**
-	 * Adds a generic marker and decoration to the buffer
+	 * Adds a generic marker to the buffer
 	 */
-	addGenericMarker(genericMarkProperties: IGenericMarkProperties): void;
+	addGenericMarker(): void;
+
+	/**
+	 * Adds a decoration to the buffer
+	 * @param genericMarkProperties
+	 */
+	addDecoration(genericMarkProperties: IGenericMarkProperties): void;
 
 	/**
 	 * Dispose the terminal instance, removing it from the panel/service and freeing up resources.
@@ -932,6 +939,11 @@ export interface IXtermTerminal {
 	 */
 	clearActiveSearchDecoration(): void;
 
+	/**
+	 * Adds a decoration at the @param marker with the given properties
+	 * @param properties
+	 */
+	addDecoration(marker: IMarker, properties: IGenericMarkProperties): void;
 }
 
 export interface IInternalXtermTerminal {

src/vs/workbench/contrib/terminal/browser/terminalInstance.ts

@@ -82,8 +82,7 @@ import { IHistoryService } from 'vs/workbench/services/history/common/history';
 import { IWorkbenchLayoutService, Position } from 'vs/workbench/services/layout/browser/layoutService';
 import { IPathService } from 'vs/workbench/services/path/common/pathService';
 import { IPreferencesService } from 'vs/workbench/services/preferences/common/preferences';
-import type { ITerminalAddon, Terminal as XTermTerminal } from 'xterm';
-import { ITermOscPt, ITermSequence } from 'vs/workbench/contrib/terminal/browser/terminalEscapeSequences';
+import type { IMarker, ITerminalAddon, Terminal as XTermTerminal } from 'xterm';
 import { IOpenerService } from 'vs/platform/opener/common/opener';
 import { IGenericMarkProperties } from 'vs/platform/terminal/common/terminalProcess';
 
@@ -214,6 +213,7 @@ export class TerminalInstance extends Disposable implements ITerminalInstance {
 	private _target?: TerminalLocation | undefined;
 	private _disableShellIntegrationReporting: boolean | undefined;
 	private _usedShellIntegrationInjection: boolean = false;
+	private _genericMarker: IMarker | undefined;
 
 	readonly capabilities = new TerminalCapabilityStoreMultiplexer();
 	readonly statusList: ITerminalStatusList;
@@ -1590,8 +1590,16 @@ export class TerminalInstance extends Disposable implements ITerminalInstance {
 		}
 	}
 
-	public addGenericMarker(genericMarkProperties: IGenericMarkProperties): void {
-		this.xterm?.raw.write(`${ITermSequence(ITermOscPt.SetMark, `${genericMarkProperties.hoverMessage || ''};${genericMarkProperties.disableCommandStorage ? true : false}`)}`);
+	public addGenericMarker(): void {
+		this._genericMarker = this.xterm?.raw.registerMarker(0);
+	}
+
+	public addDecoration(genericMarkProperties: IGenericMarkProperties): void {
+		if (this._genericMarker) {
+			this.xterm?.addDecoration(this._genericMarker, genericMarkProperties);
+		} else {
+			throw new Error(`No marker for decoration, ${genericMarkProperties}`);
+		}
 	}
 
 	private _onProcessData(ev: IProcessDataEvent): void {

src/vs/workbench/contrib/terminal/browser/xterm/xtermTerminal.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import type { IBuffer, ITheme, RendererType, Terminal as RawXtermTerminal } from 'xterm';
+import type { IBuffer, IMarker, ITheme, RendererType, Terminal as RawXtermTerminal } from 'xterm';
 import type { ISearchOptions, SearchAddon as SearchAddonType } from 'xterm-addon-search';
 import type { Unicode11Addon as Unicode11AddonType } from 'xterm-addon-unicode11';
 import type { WebglAddon as WebglAddonType } from 'xterm-addon-webgl';
@@ -35,6 +35,7 @@ import { DecorationAddon } from 'vs/workbench/contrib/terminal/browser/xterm/dec
 import { ITerminalCapabilityStore, ITerminalCommand, TerminalCapability } from 'vs/platform/terminal/common/capabilities/capabilities';
 import { Emitter } from 'vs/base/common/event';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { IGenericMarkProperties } from 'vs/platform/terminal/common/terminalProcess';
 
 // How long in milliseconds should an average frame take to render for a notification to appear
 // which suggests the fallback DOM-based renderer
@@ -179,6 +180,10 @@ export class XtermTerminal extends DisposableStore implements IXtermTerminal, II
 		this.raw.loadAddon(this._shellIntegrationAddon);
 	}
 
+	addDecoration(marker: IMarker, properties: IGenericMarkProperties): void {
+		this._capabilities.get(TerminalCapability.CommandDetection)?.handleGenericCommand(marker, properties);
+	}
+
 	async getSelectionAsHtml(command?: ITerminalCommand): Promise<string> {
 		if (!this._serializeAddon) {
 			const Addon = await this._getSerializeAddonConstructor();