chore(vscode): update to 1.56.0

lib/vscode/src/vs/platform/environment/node/argv.ts

@@ -134,6 +134,7 @@ export const OPTIONS: OptionDescriptions<Required<NativeParsedArgs>> = {
 	'ignore-certificate-errors': { type: 'boolean' },
 	'allow-insecure-localhost': { type: 'boolean' },
 	'log-net-log': { type: 'string' },
+	'vmodule': { type: 'string' },
 	'_urls': { type: 'string[]' },
 
 	_: { type: 'string[]' } // main arguments

lib/vscode/src/vs/platform/environment/node/argvHelper.ts

@@ -8,6 +8,7 @@ import { localize } from 'vs/nls';
 import { MIN_MAX_MEMORY_SIZE_MB } from 'vs/platform/files/common/files';
 import { parseArgs, ErrorReporter, OPTIONS } from 'vs/platform/environment/node/argv';
 import { NativeParsedArgs } from 'vs/platform/environment/common/argv';
+import { IProcessEnvironment } from 'vs/base/common/platform';
 
 function parseAndValidate(cmdLineArgs: string[], reportWarnings: boolean): NativeParsedArgs {
 	const errorReporter: ErrorReporter = {
@@ -79,6 +80,6 @@ export function addArg(argv: string[], ...args: string[]): string[] {
 	return argv;
 }
 
-export function isLaunchedFromCli(env: NodeJS.ProcessEnv): boolean {
+export function isLaunchedFromCli(env: IProcessEnvironment): boolean {
 	return env['VSCODE_CLI'] === '1';
 }

lib/vscode/src/vs/platform/environment/node/shellEnv.ts

@@ -3,9 +3,10 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import * as path from 'path';
 import { spawn } from 'child_process';
 import { generateUuid } from 'vs/base/common/uuid';
-import { isWindows, platform } from 'vs/base/common/platform';
+import { IProcessEnvironment, isWindows, OS } from 'vs/base/common/platform';
 import { ILogService } from 'vs/platform/log/common/log';
 import { NativeParsedArgs } from 'vs/platform/environment/common/argv';
 import { isLaunchedFromCli } from 'vs/platform/environment/node/argvHelper';
@@ -17,7 +18,7 @@ import { getSystemShell } from 'vs/base/node/shell';
  * This should only be done when Code itself is not launched
  * from within a shell.
  */
-export async function resolveShellEnv(logService: ILogService, args: NativeParsedArgs, env: NodeJS.ProcessEnv): Promise<typeof process.env> {
+export async function resolveShellEnv(logService: ILogService, args: NativeParsedArgs, env: IProcessEnvironment): Promise<typeof process.env> {
 
 	// Skip if --force-disable-user-env
 	if (args['force-disable-user-env']) {
@@ -75,31 +76,55 @@ async function doResolveUnixShellEnv(logService: ILogService): Promise<typeof pr
 			ELECTRON_NO_ATTACH_CONSOLE: '1'
 		};
 
-		const command = `'${process.execPath}' -p '"${mark}" + JSON.stringify(process.env) + "${mark}"'`;
 		logService.trace('getUnixShellEnvironment#env', env);
-		logService.trace('getUnixShellEnvironment#spawn', command);
-
-		const systemShellUnix = await getSystemShell(platform, env);
+		const systemShellUnix = await getSystemShell(OS, env);
 		logService.trace('getUnixShellEnvironment#shell', systemShellUnix);
 
-		const child = spawn(systemShellUnix, ['-ilc', command], {
+		// handle popular non-POSIX shells
+		const name = path.basename(systemShellUnix);
+		let command: string, shellArgs: Array<string>;
+		if (/^pwsh(-preview)?$/.test(name)) {
+			// Older versions of PowerShell removes double quotes sometimes so we use "double single quotes" which is how
+			// you escape single quotes inside of a single quoted string.
+			command = `& '${process.execPath}' -p '''${mark}'' + JSON.stringify(process.env) + ''${mark}'''`;
+			shellArgs = ['-Login', '-Command'];
+		} else {
+			command = `'${process.execPath}' -p '"${mark}" + JSON.stringify(process.env) + "${mark}"'`;
+			shellArgs = ['-ilc'];
+		}
+
+		logService.trace('getUnixShellEnvironment#spawn', JSON.stringify(shellArgs), command);
+
+		const child = spawn(systemShellUnix, [...shellArgs, command], {
 			detached: true,
-			stdio: ['ignore', 'pipe', process.stderr],
+			stdio: ['ignore', 'pipe', 'pipe'],
 			env
 		});
 
+		child.on('error', err => {
+			logService.error('getUnixShellEnvironment#errorChildProcess', toErrorMessage(err));
+			resolve({});
+		});
+
 		const buffers: Buffer[] = [];
-		child.on('error', () => resolve({}));
 		child.stdout.on('data', b => buffers.push(b));
 
-		child.on('close', code => {
-			if (code !== 0) {
-				return reject(new Error('Failed to get environment'));
-			}
+		const stderr: Buffer[] = [];
+		child.stderr.on('data', b => stderr.push(b));
 
+		child.on('close', (code, signal) => {
 			const raw = Buffer.concat(buffers).toString('utf8');
 			logService.trace('getUnixShellEnvironment#raw', raw);
 
+			const stderrStr = Buffer.concat(stderr).toString('utf8');
+			if (stderrStr.trim()) {
+				logService.trace('getUnixShellEnvironment#stderr', stderrStr);
+			}
+
+			if (code || signal) {
+				return reject(new Error(`Failed to get environment (code ${code}, signal ${signal})`));
+			}
+
 			const match = regex.exec(raw);
 			const rawStripped = match ? match[1] : '{}';
 
@@ -124,7 +149,7 @@ async function doResolveUnixShellEnv(logService: ILogService): Promise<typeof pr
 				logService.trace('getUnixShellEnvironment#result', env);
 				resolve(env);
 			} catch (err) {
-				logService.error('getUnixShellEnvironment#error', err);
+				logService.error('getUnixShellEnvironment#errorCaught', toErrorMessage(err));
 				reject(err);
 			}
 		});

lib/vscode/src/vs/platform/environment/node/userDataPath.js

@@ -10,23 +10,39 @@
 	'use strict';
 
 	/**
+	 * @typedef {import('../../environment/common/argv').NativeParsedArgs} NativeParsedArgs
+	 *
 	 * @param {typeof import('path')} path
 	 * @param {typeof import('os')} os
 	 * @param {string} productName
+	 * @param {string} cwd
 	 */
-	function factory(path, os, productName) {
+	function factory(path, os, productName, cwd) {
 
 		/**
-		 * @param {import('../../environment/common/argv').NativeParsedArgs} cliArgs
+		 * @param {NativeParsedArgs} cliArgs
 		 *
 		 * @returns {string}
 		 */
 		function getUserDataPath(cliArgs) {
-			return path.resolve(doGetUserDataPath(cliArgs));
+			const userDataPath = doGetUserDataPath(cliArgs);
+			const pathsToResolve = [userDataPath];
+
+			// If the user-data-path is not absolute, make
+			// sure to resolve it against the passed in
+			// current working directory. We cannot use the
+			// node.js `path.resolve()` logic because it will
+			// not pick up our `VSCODE_CWD` environment variable
+			// (https://github.com/microsoft/vscode/issues/120269)
+			if (!path.isAbsolute(userDataPath)) {
+				pathsToResolve.unshift(cwd);
+			}
+
+			return path.resolve(...pathsToResolve);
 		}
 
 		/**
-		 * @param {import('../../environment/common/argv').NativeParsedArgs} cliArgs
+		 * @param {NativeParsedArgs} cliArgs
 		 *
 		 * @returns {string}
 		 */
@@ -81,18 +97,25 @@
 	}
 
 	if (typeof define === 'function') {
-		define(['require', 'path', 'os', 'vs/base/common/network', 'vs/base/common/resources'], function (require, /** @type {typeof import('path')} */ path, /** @type {typeof import('os')} */ os, /** @type {typeof import('../../../base/common/network')} */ network, /** @type {typeof import("../../../base/common/resources")} */ resources) {
+		define(['require', 'path', 'os', 'vs/base/common/network', 'vs/base/common/resources', 'vs/base/common/process'], function (
+			require,
+			/** @type {typeof import('path')} */ path,
+			/** @type {typeof import('os')} */ os,
+			/** @type {typeof import('../../../base/common/network')} */ network,
+			/** @type {typeof import("../../../base/common/resources")} */ resources,
+			/** @type {typeof import("../../../base/common/process")} */ process
+		) {
 			const rootPath = resources.dirname(network.FileAccess.asFileUri('', require));
 			const pkg = require.__$__nodeRequire(resources.joinPath(rootPath, 'package.json').fsPath);
 
-			return factory(path, os, pkg.name);
+			return factory(path, os, pkg.name, process.cwd());
 		}); // amd
 	} else if (typeof module === 'object' && typeof module.exports === 'object') {
 		const pkg = require('../../../../../package.json');
 		const path = require('path');
 		const os = require('os');
 
-		module.exports = factory(path, os, pkg.name); // commonjs
+		module.exports = factory(path, os, pkg.name, process.env['VSCODE_CWD'] || process.cwd()); // commonjs
 	} else {
 		throw new Error('Unknown context');
 	}