Merge from vscode ec07311dab2556c9d66a4cb3eecdc21c524202e1 (#6739)

src/vs/workbench/api/browser/mainThreadTreeViews.ts

@@ -124,7 +124,7 @@ export class MainThreadTreeViews extends Disposable implements MainThreadTreeVie
 		this._dataProviders.forEach((dataProvider, treeViewId) => {
 			const treeView = this.getTreeView(treeViewId);
 			if (treeView) {
-				treeView.dataProvider = null;
+				treeView.dataProvider = undefined;
 			}
 		});
 		this._dataProviders.clear();

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

@@ -15,7 +15,7 @@ import { OverviewRulerLane } from 'vs/editor/common/model';
 import * as languageConfiguration from 'vs/editor/common/modes/languageConfiguration';
 import { score } from 'vs/editor/common/modes/languageSelector';
 import * as files from 'vs/platform/files/common/files';
-import { ExtHostContext, MainContext } from 'vs/workbench/api/common/extHost.protocol';
+import { ExtHostContext, MainContext, ExtHostLogServiceShape } from 'vs/workbench/api/common/extHost.protocol';
 import { ExtHostApiCommands } from 'vs/workbench/api/common/extHostApiCommands';
 import { ExtHostClipboard } from 'vs/workbench/api/common/extHostClipboard';
 import { IExtHostCommands } from 'vs/workbench/api/common/extHostCommands';
@@ -33,7 +33,6 @@ import { ExtHostFileSystem } from 'vs/workbench/api/common/extHostFileSystem';
 import { ExtHostFileSystemEventService } from 'vs/workbench/api/common/extHostFileSystemEventService';
 import { ExtHostLanguageFeatures } from 'vs/workbench/api/common/extHostLanguageFeatures';
 import { ExtHostLanguages } from 'vs/workbench/api/common/extHostLanguages';
-import { ExtHostLogService } from 'vs/workbench/api/common/extHostLogService';
 import { ExtHostMessageService } from 'vs/workbench/api/common/extHostMessageService';
 import { IExtHostOutputService } from 'vs/workbench/api/common/extHostOutput';
 import { ExtHostProgress } from 'vs/workbench/api/common/extHostProgress';
@@ -95,10 +94,10 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 	const uriTransformer = accessor.get(IURITransformerService);
 	const rpcProtocol = accessor.get(IExtHostRpcService);
 	const extHostStorage = accessor.get(IExtHostStorage);
-	const extHostLogService = <ExtHostLogService>accessor.get(ILogService);
+	const extHostLogService = accessor.get(ILogService);
 
 	// register addressable instances
-	rpcProtocol.set(ExtHostContext.ExtHostLogService, extHostLogService);
+	rpcProtocol.set(ExtHostContext.ExtHostLogService, <ExtHostLogServiceShape><any>extHostLogService);
 	rpcProtocol.set(ExtHostContext.ExtHostWorkspace, extHostWorkspace);
 	rpcProtocol.set(ExtHostContext.ExtHostConfiguration, extHostConfiguration);
 	rpcProtocol.set(ExtHostContext.ExtHostExtensionService, extensionService);
@@ -147,10 +146,6 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 	const extHostStatusBar = new ExtHostStatusBar(rpcProtocol);
 	const extHostLanguages = new ExtHostLanguages(rpcProtocol, extHostDocuments);
 
-	// Register an output channel for exthost log
-	const outputChannelName = initData.remote.isRemote ? nls.localize('remote extension host Log', "Remote Extension Host") : nls.localize('extension host Log', "Extension Host");
-	extHostOutputService.createOutputChannelFromLogFile(outputChannelName, extHostLogService.logFile);
-
 	// Register API-ish commands
 	ExtHostApiCommands.register(extHostCommands);
 

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

@@ -14,7 +14,6 @@ import { ILogService } from 'vs/platform/log/common/log';
 import { ExtHostExtensionServiceShape, IInitData, MainContext, MainThreadExtensionServiceShape, MainThreadTelemetryShape, MainThreadWorkspaceShape, IResolveAuthorityResult } from 'vs/workbench/api/common/extHost.protocol';
 import { ExtHostConfiguration, IExtHostConfiguration } from 'vs/workbench/api/common/extHostConfiguration';
 import { ActivatedExtension, EmptyExtension, ExtensionActivatedByAPI, ExtensionActivatedByEvent, ExtensionActivationReason, ExtensionActivationTimes, ExtensionActivationTimesBuilder, ExtensionsActivator, IExtensionAPI, IExtensionContext, IExtensionModule, HostExtension, ExtensionActivationTimesFragment } from 'vs/workbench/api/common/extHostExtensionActivator';
-import { ExtHostLogService } from 'vs/workbench/api/common/extHostLogService';
 import { ExtHostStorage, IExtHostStorage } from 'vs/workbench/api/common/extHostStorage';
 import { ExtHostWorkspace, IExtHostWorkspace } from 'vs/workbench/api/common/extHostWorkspace';
 import { ExtensionActivationError } from 'vs/workbench/services/extensions/common/extensions';
@@ -75,7 +74,7 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 	protected readonly _instaService: IInstantiationService;
 	protected readonly _extHostWorkspace: ExtHostWorkspace;
 	protected readonly _extHostConfiguration: ExtHostConfiguration;
-	protected readonly _extHostLogService: ExtHostLogService;
+	protected readonly _logService: ILogService;
 
 	protected readonly _mainThreadWorkspaceProxy: MainThreadWorkspaceShape;
 	protected readonly _mainThreadTelemetryProxy: MainThreadTelemetryShape;
@@ -102,7 +101,7 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 		@IExtHostRpcService extHostContext: IExtHostRpcService,
 		@IExtHostWorkspace extHostWorkspace: IExtHostWorkspace,
 		@IExtHostConfiguration extHostConfiguration: IExtHostConfiguration,
-		@ILogService extHostLogService: ExtHostLogService,
+		@ILogService logService: ILogService,
 		@IExtHostInitDataService initData: IExtHostInitDataService,
 		@IExtensionStoragePaths storagePath: IExtensionStoragePaths
 	) {
@@ -112,7 +111,7 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 
 		this._extHostWorkspace = extHostWorkspace;
 		this._extHostConfiguration = extHostConfiguration;
-		this._extHostLogService = extHostLogService;
+		this._logService = logService;
 		this._disposables = new DisposableStore();
 
 		this._mainThreadWorkspaceProxy = this._extHostContext.getProxy(MainContext.MainThreadWorkspace);
@@ -329,14 +328,14 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 			return Promise.resolve(new EmptyExtension(ExtensionActivationTimes.NONE));
 		}
 
-		this._extHostLogService.info(`ExtensionService#_doActivateExtension ${extensionDescription.identifier.value} ${JSON.stringify(reason)}`);
+		this._logService.info(`ExtensionService#_doActivateExtension ${extensionDescription.identifier.value} ${JSON.stringify(reason)}`);
 
 		const activationTimesBuilder = new ExtensionActivationTimesBuilder(reason.startup);
 		return Promise.all<any>([
 			this._loadCommonJSModule(extensionDescription.main, activationTimesBuilder),
 			this._loadExtensionContext(extensionDescription)
 		]).then(values => {
-			return AbstractExtHostExtensionService._callActivate(this._extHostLogService, extensionDescription.identifier, <IExtensionModule>values[0], <IExtensionContext>values[1], activationTimesBuilder);
+			return AbstractExtHostExtensionService._callActivate(this._logService, extensionDescription.identifier, <IExtensionModule>values[0], <IExtensionContext>values[1], activationTimesBuilder);
 		});
 	}
 
@@ -347,7 +346,7 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 		const globalState = new ExtensionMemento(extensionDescription.identifier.value, true, this._storage);
 		const workspaceState = new ExtensionMemento(extensionDescription.identifier.value, false, this._storage);
 
-		this._extHostLogService.trace(`ExtensionService#loadExtensionContext ${extensionDescription.identifier.value}`);
+		this._logService.trace(`ExtensionService#loadExtensionContext ${extensionDescription.identifier.value}`);
 		return Promise.all([
 			globalState.whenReady,
 			workspaceState.whenReady,
@@ -359,10 +358,10 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 				workspaceState,
 				subscriptions: [],
 				get extensionPath() { return extensionDescription.extensionLocation.fsPath; },
-				storagePath: this._storagePath.workspaceValue(extensionDescription),
-				globalStoragePath: this._storagePath.globalValue(extensionDescription),
+				get storagePath() { return that._storagePath.workspaceValue(extensionDescription); },
+				get globalStoragePath() { return that._storagePath.globalValue(extensionDescription); },
 				asAbsolutePath: (relativePath: string) => { return path.join(extensionDescription.extensionLocation.fsPath, relativePath); },
-				logPath: that._extHostLogService.getLogDirectory(extensionDescription.identifier),
+				get logPath() { return path.join(that._initData.logsLocation.fsPath, extensionDescription.identifier.value); },
 				executionContext: this._initData.remote.isRemote ? ExtensionExecutionContext.Remote : ExtensionExecutionContext.Local,
 			});
 		});
@@ -385,7 +384,8 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 			try {
 				activationTimesBuilder.activateCallStart();
 				logService.trace(`ExtensionService#_callActivateOptional ${extensionId.value}`);
-				const activateResult: Promise<IExtensionAPI> = extensionModule.activate.apply(global, [context]);
+				const scope = typeof global === 'object' ? global : self; // `global` is nodejs while `self` is for workers
+				const activateResult: Promise<IExtensionAPI> = extensionModule.activate.apply(scope, [context]);
 				activationTimesBuilder.activateCallStop();
 
 				activationTimesBuilder.activateResolveStart();
@@ -478,7 +478,7 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 	}
 
 	private async _activateIfGlobPatterns(folders: ReadonlyArray<vscode.WorkspaceFolder>, extensionId: ExtensionIdentifier, globPatterns: string[]): Promise<void> {
-		this._extHostLogService.trace(`extensionHostMain#activateIfGlobPatterns: fileSearch, extension: ${extensionId.value}, entryPoint: workspaceContains`);
+		this._logService.trace(`extensionHostMain#activateIfGlobPatterns: fileSearch, extension: ${extensionId.value}, entryPoint: workspaceContains`);
 
 		if (globPatterns.length === 0) {
 			return Promise.resolve(undefined);
@@ -525,7 +525,7 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 	}
 
 	private async _doHandleExtensionTests(): Promise<void> {
-		const { extensionDevelopmentLocationURI: extensionDevelopmentLocationURI, extensionTestsLocationURI } = this._initData.environment;
+		const { extensionDevelopmentLocationURI, extensionTestsLocationURI } = this._initData.environment;
 		if (!(extensionDevelopmentLocationURI && extensionTestsLocationURI && extensionTestsLocationURI.scheme === Schemas.file)) {
 			return Promise.resolve(undefined);
 		}
@@ -605,7 +605,7 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 			.then(() => this._handleEagerExtensions())
 			.then(() => this._handleExtensionTests())
 			.then(() => {
-				this._extHostLogService.info(`eager extensions activated`);
+				this._logService.info(`eager extensions activated`);
 			});
 	}
 

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

@@ -1,34 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { join } from 'vs/base/common/path';
-import { ILogService, DelegatedLogService, LogLevel } from 'vs/platform/log/common/log';
-import { ExtHostLogServiceShape } from 'vs/workbench/api/common/extHost.protocol';
-import { ExtensionHostLogFileName } from 'vs/workbench/services/extensions/common/extensions';
-import { URI } from 'vs/base/common/uri';
-import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
-
-export class ExtHostLogService extends DelegatedLogService implements ILogService, ExtHostLogServiceShape {
-
-	private _logsPath: string;
-	readonly logFile: URI;
-
-	constructor(
-		delegate: ILogService,
-		logsPath: string,
-	) {
-		super(delegate);
-		this._logsPath = logsPath;
-		this.logFile = URI.file(join(logsPath, `${ExtensionHostLogFileName}.log`));
-	}
-
-	$setLevel(level: LogLevel): void {
-		this.setLevel(level);
-	}
-
-	getLogDirectory(extensionID: ExtensionIdentifier): string {
-		return join(this._logsPath, extensionID.value);
-	}
-}

src/vs/workbench/api/node/extHost.services.ts

@@ -24,8 +24,11 @@ import { IExtensionStoragePaths } from 'vs/workbench/api/common/extHostStoragePa
 import { IExtHostExtensionService } from 'vs/workbench/api/common/extHostExtensionService';
 import { ExtHostExtensionService } from 'vs/workbench/api/node/extHostExtensionService';
 import { IExtHostStorage, ExtHostStorage } from 'vs/workbench/api/common/extHostStorage';
+import { ILogService } from 'vs/platform/log/common/log';
+import { ExtHostLogService } from 'vs/workbench/api/node/extHostLogService';
 
 // register singleton services
+registerSingleton(ILogService, ExtHostLogService);
 registerSingleton(IExtHostOutputService, ExtHostOutputService2);
 registerSingleton(IExtHostWorkspace, ExtHostWorkspace);
 registerSingleton(IExtHostDecorations, ExtHostDecorations);

src/vs/workbench/api/node/extHostExtensionService.ts

@@ -44,14 +44,24 @@ export class ExtHostExtensionService extends AbstractExtHostExtensionService {
 		}
 
 		// Do this when extension service exists, but extensions are not being activated yet.
-		await connectProxyResolver(this._extHostWorkspace, configProvider, this, this._extHostLogService, this._mainThreadTelemetryProxy);
+		await connectProxyResolver(this._extHostWorkspace, configProvider, this, this._logService, this._mainThreadTelemetryProxy);
 
+		// Use IPC messages to forward console-calls, note that the console is
+		// already patched to use`process.send()`
+		const nativeProcessSend = process.send!;
+		const mainThreadConsole = this._extHostContext.getProxy(MainContext.MainThreadConsole);
+		process.send = (...args: any[]) => {
+			if (args.length === 0 || !args[0] || args[0].type !== '__$console') {
+				return nativeProcessSend.apply(process, args);
+			}
+			mainThreadConsole.$logExtensionHostMessage(args[0]);
+		};
 	}
 
 	protected _loadCommonJSModule<T>(modulePath: string, activationTimesBuilder: ExtensionActivationTimesBuilder): Promise<T> {
 		let r: T | null = null;
 		activationTimesBuilder.codeLoadingStart();
-		this._extHostLogService.info(`ExtensionService#loadCommonJSModule ${modulePath}`);
+		this._logService.info(`ExtensionService#loadCommonJSModule ${modulePath}`);
 		try {
 			r = require.__$__nodeRequire<T>(modulePath);
 		} catch (e) {

src/vs/workbench/api/node/extHostLogService.ts

@@ -0,0 +1,36 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { localize } from 'vs/nls';
+import { join } from 'vs/base/common/path';
+import { ILogService, DelegatedLogService, LogLevel } from 'vs/platform/log/common/log';
+import { ExtHostLogServiceShape } from 'vs/workbench/api/common/extHost.protocol';
+import { ExtensionHostLogFileName } from 'vs/workbench/services/extensions/common/extensions';
+import { URI } from 'vs/base/common/uri';
+import { IExtHostInitDataService } from 'vs/workbench/api/common/extHostInitDataService';
+import { Schemas } from 'vs/base/common/network';
+import { SpdLogService } from 'vs/platform/log/node/spdlogService';
+import { IExtHostOutputService } from 'vs/workbench/api/common/extHostOutput';
+
+export class ExtHostLogService extends DelegatedLogService implements ILogService, ExtHostLogServiceShape {
+
+	constructor(
+		@IExtHostInitDataService initData: IExtHostInitDataService,
+		@IExtHostOutputService extHostOutputService: IExtHostOutputService
+	) {
+		if (initData.logsLocation.scheme !== Schemas.file) { throw new Error('Only file-logging supported'); }
+		super(new SpdLogService(ExtensionHostLogFileName, initData.logsLocation.fsPath, initData.logLevel));
+
+		// Register an output channel for exthost log
+		extHostOutputService.createOutputChannelFromLogFile(
+			initData.remote.isRemote ? localize('remote extension host Log', "Remote Extension Host") : localize('extension host Log', "Extension Host"),
+			URI.file(join(initData.logsLocation.fsPath, `${ExtensionHostLogFileName}.log`))
+		);
+	}
+
+	$setLevel(level: LogLevel): void {
+		this.setLevel(level);
+	}
+}

src/vs/workbench/api/worker/extHostExtensionService.ts

@@ -0,0 +1,98 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { createApiFactoryAndRegisterActors, IExtensionApiFactory } from 'vs/workbench/api/common/extHost.api.impl';
+import { ExtensionActivationTimesBuilder } from 'vs/workbench/api/common/extHostExtensionActivator';
+import { AbstractExtHostExtensionService } from 'vs/workbench/api/common/extHostExtensionService';
+import { endsWith } from 'vs/base/common/strings';
+import { IExtensionDescription, ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+import { ExtHostConfigProvider } from 'vs/workbench/api/common/extHostConfiguration';
+import * as vscode from 'vscode';
+import { TernarySearchTree } from 'vs/base/common/map';
+import { nullExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';
+import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/common/extensionDescriptionRegistry';
+
+class ApiInstances {
+
+	private readonly _apiInstances = new Map<string, typeof vscode>();
+
+	constructor(
+		private readonly _apiFactory: IExtensionApiFactory,
+		private readonly _extensionPaths: TernarySearchTree<IExtensionDescription>,
+		private readonly _extensionRegistry: ExtensionDescriptionRegistry,
+		private readonly _configProvider: ExtHostConfigProvider,
+	) {
+		//
+	}
+
+	get(modulePath: string): typeof vscode {
+		const extension = this._extensionPaths.findSubstr(modulePath) || nullExtensionDescription;
+		const id = ExtensionIdentifier.toKey(extension.identifier);
+
+		let apiInstance = this._apiInstances.get(id);
+		if (!apiInstance) {
+			apiInstance = this._apiFactory(extension, this._extensionRegistry, this._configProvider);
+			this._apiInstances.set(id, apiInstance);
+		}
+		return apiInstance;
+	}
+}
+
+export class ExtHostExtensionService extends AbstractExtHostExtensionService {
+
+	private _apiInstances?: ApiInstances;
+
+	protected async _beforeAlmostReadyToRunExtensions(): Promise<void> {
+		// initialize API and register actors
+		const apiFactory = this._instaService.invokeFunction(createApiFactoryAndRegisterActors);
+		const configProvider = await this._extHostConfiguration.getConfigProvider();
+		const extensionPath = await this.getExtensionPathIndex();
+		this._apiInstances = new ApiInstances(apiFactory, extensionPath, this._registry, configProvider);
+	}
+
+	protected _loadCommonJSModule<T>(modulePath: string, activationTimesBuilder: ExtensionActivationTimesBuilder): Promise<T> {
+
+		// make sure modulePath ends with `.js`
+		const suffix = '.js';
+		modulePath = endsWith(modulePath, suffix) ? modulePath : modulePath + suffix;
+
+		interface FakeCommonJSSelf {
+			module?: object;
+			exports?: object;
+			require?: (module: string) => any;
+			window?: object;
+			__dirname: never;
+			__filename: never;
+		}
+
+		// FAKE commonjs world that only collects exports
+		const patchSelf: FakeCommonJSSelf = <any>self;
+		const module = { exports: {} };
+		patchSelf.module = module;
+		patchSelf.exports = module.exports;
+		patchSelf.window = self; // <- that's improper but might help extensions that aren't authored correctly
+
+		// FAKE require function that only works for the vscode-module
+		patchSelf.require = (module: string) => {
+			if (module !== 'vscode') {
+				throw new Error(`Cannot load module '${module}'`);
+			}
+			return this._apiInstances!.get(modulePath);
+		};
+
+		try {
+			activationTimesBuilder.codeLoadingStart();
+			importScripts(modulePath);
+		} finally {
+			activationTimesBuilder.codeLoadingStop();
+		}
+
+		return Promise.resolve(module.exports as T);
+	}
+
+	async $setRemoteEnvironment(env: { [key: string]: string | null }): Promise<void> {
+		throw new Error('Not supported');
+	}
+}

src/vs/workbench/api/worker/extHostLogService.ts

@@ -0,0 +1,84 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ILogService, LogLevel, AbstractLogService } from 'vs/platform/log/common/log';
+import { ExtHostLogServiceShape } from 'vs/workbench/api/common/extHost.protocol';
+import { IExtHostInitDataService } from 'vs/workbench/api/common/extHostInitDataService';
+import { IExtHostOutputService } from 'vs/workbench/api/common/extHostOutput';
+import * as vscode from 'vscode';
+
+export class ExtHostLogService extends AbstractLogService implements ILogService, ExtHostLogServiceShape {
+
+	_serviceBrand: any;
+
+	private readonly _logChannel: vscode.OutputChannel;
+
+	constructor(
+		@IExtHostInitDataService initData: IExtHostInitDataService,
+		@IExtHostOutputService extHostOutputService: IExtHostOutputService
+	) {
+		super();
+		this.setLevel(initData.logLevel);
+		this._logChannel = extHostOutputService.createOutputChannel('Log (Worker Extension Host)');
+	}
+
+	$setLevel(level: LogLevel): void {
+		this.setLevel(level);
+	}
+
+	trace(_message: string, ..._args: any[]): void {
+		if (this.getLevel() <= LogLevel.Trace) {
+			this._logChannel.appendLine(this._format(arguments));
+		}
+	}
+
+	debug(_message: string, ..._args: any[]): void {
+		if (this.getLevel() <= LogLevel.Debug) {
+			this._logChannel.appendLine(this._format(arguments));
+		}
+	}
+
+	info(_message: string, ..._args: any[]): void {
+		if (this.getLevel() <= LogLevel.Info) {
+			this._logChannel.appendLine(this._format(arguments));
+		}
+	}
+
+	warn(_message: string, ..._args: any[]): void {
+		if (this.getLevel() <= LogLevel.Warning) {
+			this._logChannel.appendLine(this._format(arguments));
+		}
+	}
+
+	error(_message: string | Error, ..._args: any[]): void {
+		if (this.getLevel() <= LogLevel.Error) {
+			this._logChannel.appendLine(this._format(arguments));
+		}
+	}
+
+	critical(_message: string | Error, ..._args: any[]): void {
+		if (this.getLevel() <= LogLevel.Critical) {
+			this._logChannel.appendLine(String(arguments));
+		}
+	}
+
+	private _format(args: any): string {
+		let result = '';
+
+		for (let i = 0; i < args.length; i++) {
+			let a = args[i];
+
+			if (typeof a === 'object') {
+				try {
+					a = JSON.stringify(a);
+				} catch (e) { }
+			}
+
+			result += (i > 0 ? ' ' : '') + a;
+		}
+
+		return result;
+	}
+}