Merge remote-tracking branch 'origin/main' into tyriar/185254

Author: Tyriar

src/vs/platform/actions/browser/buttonbar.ts

@@ -18,6 +18,7 @@ import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 export type IButtonConfigProvider = (action: IAction) => {
 	showIcon?: boolean;
 	showLabel?: boolean;
+	isSecondary?: boolean;
 } | undefined;
 
 export interface IMenuWorkbenchButtonBarOptions {
@@ -68,6 +69,7 @@ export class MenuWorkbenchButtonBar extends ButtonBar {
 				.flatMap(entry => entry[1]);
 
 			for (let i = 0; i < actions.length; i++) {
+
 				const secondary = i > 0;
 				const actionOrSubmenu = actions[i];
 				let action: MenuItemAction | SubmenuItemAction;
@@ -77,14 +79,16 @@ export class MenuWorkbenchButtonBar extends ButtonBar {
 					const [first, ...rest] = actionOrSubmenu.actions;
 					action = <MenuItemAction>first;
 					btn = this.addButtonWithDropdown({
-						secondary,
+						secondary: conifgProvider(action)?.isSecondary ?? secondary,
 						actionRunner,
 						actions: rest,
 						contextMenuProvider: contextMenuService,
 					});
 				} else {
 					action = actionOrSubmenu;
-					btn = this.addButton({ secondary });
+					btn = this.addButton({
+						secondary: conifgProvider(action)?.isSecondary ?? secondary,
+					});
 				}
 
 				btn.enabled = action.enabled;

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

@@ -112,7 +112,7 @@ export class CommandDetectionCapability implements ICommandDetectionCapability {
 
 	constructor(
 		private readonly _terminal: Terminal,
-		@ILogService private readonly _logService: ILogService
+		private readonly _logService: ILogService
 	) {
 		this._dimensions = {
 			cols: this._terminal.cols,

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

@@ -15,6 +15,7 @@ import { RawContextKey } from 'vs/platform/contextkey/common/contextkey';
 import { IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
 import { Registry } from 'vs/platform/registry/common/platform';
 import type * as performance from 'vs/base/common/performance';
+import { ILogService } from 'vs/platform/log/common/log';
 
 export const terminalTabFocusContextKey = new RawContextKey<boolean>('terminalTabFocusMode', false, true);
 
@@ -1057,3 +1058,13 @@ export const ILocalPtyService = createDecorator<ILocalPtyService>('localPtyServi
  * **This service should only be used within the terminal component.**
  */
 export interface ILocalPtyService extends IPtyService { }
+
+export const ITerminalLogService = createDecorator<ITerminalLogService>('terminalLogService');
+export interface ITerminalLogService extends ILogService {
+	/**
+	 * Similar to _serviceBrand but used to differentiate this service at compile time from
+	 * ILogService; ITerminalLogService is an ILogService, but ILogService is not an
+	 * ITerminalLogService.
+	 */
+	readonly _logBrand: undefined;
+}

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

@@ -0,0 +1,33 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable } from 'vs/base/common/lifecycle';
+import { Event } from 'vs/base/common/event';
+import { localize } from 'vs/nls';
+import { ILogger, ILoggerService, LogLevel } from 'vs/platform/log/common/log';
+import { ITerminalLogService } from 'vs/platform/terminal/common/terminal';
+
+export class TerminalLogService extends Disposable implements ITerminalLogService {
+	declare _serviceBrand: undefined;
+	declare _logBrand: undefined;
+
+	private readonly _logger: ILogger;
+
+	get onDidChangeLogLevel(): Event<LogLevel> { return this._logger.onDidChangeLogLevel; }
+
+	constructor(@ILoggerService private readonly _loggerService: ILoggerService) {
+		super();
+		this._logger = this._loggerService.createLogger('terminal', { name: localize('terminalLoggerName', 'Terminal') });
+	}
+
+	getLevel(): LogLevel { return this._logger.getLevel(); }
+	setLevel(level: LogLevel): void { this._logger.setLevel(level); }
+	trace(message: string, ...args: any[]): void { this._logger.trace(message, args); }
+	debug(message: string, ...args: any[]): void { this._logger.debug(message, args); }
+	info(message: string, ...args: any[]): void { this._logger.info(message, args); }
+	warn(message: string, ...args: any[]): void { this._logger.warn(message, args); }
+	error(message: string | Error, ...args: any[]): void { this._logger.error(message, args); }
+	flush(): void { this._logger.flush(); }
+}

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

@@ -209,7 +209,7 @@ export class ShellIntegrationAddon extends Disposable implements IShellIntegrati
 		private _nonce: string,
 		private readonly _disableTelemetry: boolean | undefined,
 		private readonly _telemetryService: ITelemetryService | undefined,
-		@ILogService private readonly _logService: ILogService
+		private readonly _logService: ILogService
 	) {
 		super();
 		this._register(toDisposable(() => {

src/vs/platform/terminal/node/ptyHostMain.ts

@@ -43,6 +43,12 @@ async function startPtyHost() {
 	delete process.env.VSCODE_STARTUP_DELAY;
 	delete process.env.VSCODE_LAST_PTY_ID;
 
+	// Delay startup if needed, this must occur before RPC is setup to avoid the channel from timing
+	// out.
+	if (startupDelay) {
+		await timeout(startupDelay);
+	}
+
 	// Setup RPC
 	const _isUtilityProcess = isUtilityProcess(process);
 	let server: ChildProcessServer<string> | UtilityProcessServer;
@@ -60,10 +66,9 @@ async function startPtyHost() {
 	const logger = loggerService.createLogger('ptyhost', { name: localize('ptyHost', "Pty Host") });
 	const logService = new LogService(logger, [new ConsoleLogger()]);
 
-	// Log and apply developer config
+	// Log developer config
 	if (startupDelay) {
 		logService.warn(`Pty Host startup is delayed ${startupDelay}ms`);
-		await timeout(startupDelay);
 	}
 	if (simulatedLatency) {
 		logService.warn(`Pty host is simulating ${simulatedLatency}ms latency`);

src/vs/server/node/remoteTerminalChannel.ts

@@ -13,7 +13,6 @@ import { URI } from 'vs/base/common/uri';
 import { IURITransformer } from 'vs/base/common/uriIpc';
 import { IServerChannel } from 'vs/base/parts/ipc/common/ipc';
 import { createRandomIPCHandle } from 'vs/base/parts/ipc/node/ipc.net';
-import { ILogService } from 'vs/platform/log/common/log';
 import { RemoteAgentConnectionContext } from 'vs/platform/remote/common/remoteAgentEnvironment';
 import { IPtyService, IShellLaunchConfig, ITerminalProfile } from 'vs/platform/terminal/common/terminal';
 import { IGetTerminalLayoutInfoArgs, ISetTerminalLayoutInfoArgs } from 'vs/platform/terminal/common/terminalProcess';
@@ -32,6 +31,7 @@ import { IProductService } from 'vs/platform/product/common/productService';
 import { IExtensionManagementService } from 'vs/platform/extensionManagement/common/extensionManagement';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { withNullAsUndefined } from 'vs/base/common/types';
+import { ILogService } from 'vs/platform/log/common/log';
 
 class CustomVariableResolver extends AbstractVariableResolverService {
 	constructor(

src/vs/workbench/api/common/extHost.api.impl.ts

@@ -1462,7 +1462,6 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 			ThemeColor: extHostTypes.ThemeColor,
 			ThemeIcon: extHostTypes.ThemeIcon,
 			TreeItem: extHostTypes.TreeItem,
-			TreeItem2: extHostTypes.TreeItem,
 			TreeItemCheckboxState: extHostTypes.TreeItemCheckboxState,
 			TreeItemCollapsibleState: extHostTypes.TreeItemCollapsibleState,
 			TypeHierarchyItem: extHostTypes.TypeHierarchyItem,

src/vs/workbench/api/common/extHostTreeViews.ts

@@ -22,7 +22,6 @@ import { IExtensionDescription } from 'vs/platform/extensions/common/extensions'
 import { MarkdownString, ViewBadge, DataTransfer } from 'vs/workbench/api/common/extHostTypeConverters';
 import { IMarkdownString } from 'vs/base/common/htmlContent';
 import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';
-import { checkProposedApiEnabled } from 'vs/workbench/services/extensions/common/extensions';
 import { ITreeViewsDnDService, TreeViewsDnDService } from 'vs/editor/common/services/treeViewsDnd';
 import { IAccessibilityInformation } from 'vs/platform/accessibility/common/accessibility';
 
@@ -103,7 +102,6 @@ export class ExtHostTreeViews implements ExtHostTreeViewsShape {
 			get visible() { return treeView.visible; },
 			get onDidChangeVisibility() { return treeView.onDidChangeVisibility; },
 			get onDidChangeCheckboxState() {
-				checkProposedApiEnabled(extension, 'treeItemCheckbox');
 				return treeView.onDidChangeCheckboxState;
 			},
 			get message() { return treeView.message; },
@@ -500,7 +498,7 @@ class ExtHostTreeView<T> extends Disposable {
 	}
 
 	async setCheckboxState(checkboxUpdates: CheckboxUpdate[]) {
-		type CheckboxUpdateWithItem = { extensionItem: NonNullable<T>; treeItem: vscode.TreeItem2; newState: TreeItemCheckboxState };
+		type CheckboxUpdateWithItem = { extensionItem: NonNullable<T>; treeItem: vscode.TreeItem; newState: TreeItemCheckboxState };
 		const items = (await Promise.all(checkboxUpdates.map(async checkboxUpdate => {
 			const extensionItem = this.getExtensionElement(checkboxUpdate.treeItemHandle);
 			if (extensionItem) {
@@ -763,7 +761,7 @@ class ExtHostTreeView<T> extends Disposable {
 		return command ? { ...this.commands.toInternal(command, disposable), originalId: command.command } : undefined;
 	}
 
-	private getCheckbox(extensionTreeItem: vscode.TreeItem2): ITreeItemCheckboxState | undefined {
+	private getCheckbox(extensionTreeItem: vscode.TreeItem): ITreeItemCheckboxState | undefined {
 		if (extensionTreeItem.checkboxState === undefined) {
 			return undefined;
 		}

src/vs/workbench/api/common/extHostTypes.ts

@@ -18,7 +18,6 @@ import { FileSystemProviderErrorCode, markAsFileSystemProviderError } from 'vs/p
 import { RemoteAuthorityResolverErrorCode } from 'vs/platform/remote/common/remoteAuthorityResolver';
 import { IRelativePatternDto } from 'vs/workbench/api/common/extHost.protocol';
 import { CellEditType, ICellMetadataEdit, IDocumentMetadataEdit, isTextStreamMime } from 'vs/workbench/contrib/notebook/common/notebookCommon';
-import { checkProposedApiEnabled } from 'vs/workbench/services/extensions/common/extensions';
 import type * as vscode from 'vscode';
 
 /**
@@ -2542,10 +2541,9 @@ export class TreeItem {
 	checkboxState?: vscode.TreeItemCheckboxState;
 
 	static isTreeItem(thing: any, extension: IExtensionDescription): thing is TreeItem {
-		const treeItemThing = thing as vscode.TreeItem2;
+		const treeItemThing = thing as vscode.TreeItem;
 
 		if (treeItemThing.checkboxState !== undefined) {
-			checkProposedApiEnabled(extension, 'treeItemCheckbox');
 			const checkbox = isNumber(treeItemThing.checkboxState) ? treeItemThing.checkboxState :
 				isObject(treeItemThing.checkboxState) && isNumber(treeItemThing.checkboxState.state) ? treeItemThing.checkboxState.state : undefined;
 			const tooltip = !isNumber(treeItemThing.checkboxState) && isObject(treeItemThing.checkboxState) ? treeItemThing.checkboxState.tooltip : undefined;