Refresh master with initial release/0.24 snapshot (#332)

* Initial port of release/0.24 source code

* Fix additional headers

* Fix a typo in launch.json

src/vs/workbench/services/configurationResolver/common/configurationResolver.ts

@@ -3,10 +3,10 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import uri from 'vs/base/common/uri';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { IStringDictionary } from 'vs/base/common/collections';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
 
 export const IConfigurationResolverService = createDecorator<IConfigurationResolverService>('configurationResolverService');
 
@@ -14,9 +14,9 @@ export interface IConfigurationResolverService {
 	_serviceBrand: any;
 
 	// TODO@Isidor improve this API
-	resolve(root: uri, value: string): string;
-	resolve(root: uri, value: string[]): string[];
-	resolve(root: uri, value: IStringDictionary<string>): IStringDictionary<string>;
-	resolveAny<T>(root: uri, value: T): T;
+	resolve(root: IWorkspaceFolder, value: string): string;
+	resolve(root: IWorkspaceFolder, value: string[]): string[];
+	resolve(root: IWorkspaceFolder, value: IStringDictionary<string>): IStringDictionary<string>;
+	resolveAny<T>(root: IWorkspaceFolder, value: T): T;
 	resolveInteractiveVariables(configuration: any, interactiveVariablesMap: { [key: string]: string }): TPromise<any>;
 }

src/vs/workbench/services/configurationResolver/node/configurationResolverService.ts

@@ -3,7 +3,6 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import uri from 'vs/base/common/uri';
 import * as paths from 'vs/base/common/paths';
 import * as types from 'vs/base/common/types';
 import { TPromise } from 'vs/base/common/winjs.base';
@@ -14,13 +13,14 @@ import { IEnvironmentService } from 'vs/platform/environment/common/environment'
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { ICommandService } from 'vs/platform/commands/common/commands';
 import { ICommonCodeEditor } from 'vs/editor/common/editorCommon';
+import { IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
 import { IWorkbenchEditorService } from 'vs/workbench/services/editor/common/editorService';
 import { toResource } from 'vs/workbench/common/editor';
 
 export class ConfigurationResolverService implements IConfigurationResolverService {
 	_serviceBrand: any;
 	private _execPath: string;
-	private _workspaceRoot: string;
+	private _lastWorkspaceFolder: IWorkspaceFolder;
 
 	constructor(
 		envVariables: { [key: string]: string },
@@ -40,14 +40,26 @@ export class ConfigurationResolverService implements IConfigurationResolverServi
 	}
 
 	private get cwd(): string {
-		return this.workspaceRoot;
+		if (this.workspaceRoot) {
+			return this.workspaceRoot;
+		} else {
+			return process.cwd();
+		}
 	}
 
 	private get workspaceRoot(): string {
-		return this._workspaceRoot;
+		return this._lastWorkspaceFolder ? this._lastWorkspaceFolder.uri.fsPath : undefined;
+	}
+
+	private get workspaceFolder(): string {
+		return this.workspaceRoot;
 	}
 
 	private get workspaceRootFolderName(): string {
+		return this.workspaceFolderBasename;
+	}
+
+	private get workspaceFolderBasename(): string {
 		return this.workspaceRoot ? paths.basename(this.workspaceRoot) : '';
 	}
 
@@ -101,37 +113,43 @@ export class ConfigurationResolverService implements IConfigurationResolverServi
 		return paths.normalize(fileResource.fsPath, true);
 	}
 
-	public resolve(root: uri, value: string): string;
-	public resolve(root: uri, value: string[]): string[];
-	public resolve(root: uri, value: IStringDictionary<string>): IStringDictionary<string>;
-	public resolve(root: uri, value: any): any {
-		this._workspaceRoot = root.fsPath.toString();
-		if (types.isString(value)) {
-			return this.resolveString(root, value);
-		} else if (types.isArray(value)) {
-			return this.resolveArray(root, value);
-		} else if (types.isObject(value)) {
-			return this.resolveLiteral(root, value);
+	public resolve(root: IWorkspaceFolder, value: string): string;
+	public resolve(root: IWorkspaceFolder, value: string[]): string[];
+	public resolve(root: IWorkspaceFolder, value: IStringDictionary<string>): IStringDictionary<string>;
+	public resolve(root: IWorkspaceFolder, value: any): any {
+		try {
+			this._lastWorkspaceFolder = root;
+			if (types.isString(value)) {
+				return this.resolveString(root, value);
+			} else if (types.isArray(value)) {
+				return this.resolveArray(root, value);
+			} else if (types.isObject(value)) {
+				return this.resolveLiteral(root, value);
+			}
+			return value;
+		} finally {
+			this._lastWorkspaceFolder = undefined;
 		}
-
-		return value;
 	}
 
-	public resolveAny<T>(root: uri, value: T): T;
-	public resolveAny<T>(root: uri, value: any): any {
-		this._workspaceRoot = root.fsPath.toString();
-		if (types.isString(value)) {
-			return this.resolveString(root, value);
-		} else if (types.isArray(value)) {
-			return this.resolveAnyArray(root, value);
-		} else if (types.isObject(value)) {
-			return this.resolveAnyLiteral(root, value);
+	public resolveAny<T>(root: IWorkspaceFolder, value: T): T;
+	public resolveAny<T>(root: IWorkspaceFolder, value: any): any {
+		try {
+			this._lastWorkspaceFolder = root;
+			if (types.isString(value)) {
+				return this.resolveString(root, value);
+			} else if (types.isArray(value)) {
+				return this.resolveAnyArray(root, value);
+			} else if (types.isObject(value)) {
+				return this.resolveAnyLiteral(root, value);
+			}
+			return value;
+		} finally {
+			this._lastWorkspaceFolder = undefined;
 		}
-
-		return value;
 	}
 
-	private resolveString(root: uri, value: string): string {
+	private resolveString(root: IWorkspaceFolder, value: string): string {
 		let regexp = /\$\{(.*?)\}/g;
 		const originalValue = value;
 		const resolvedString = value.replace(regexp, (match: string, name: string) => {
@@ -146,9 +164,9 @@ export class ConfigurationResolverService implements IConfigurationResolverServi
 		return this.resolveConfigVariable(root, resolvedString, originalValue);
 	}
 
-	private resolveConfigVariable(root: uri, value: string, originalValue: string): string {
+	private resolveConfigVariable(root: IWorkspaceFolder, value: string, originalValue: string): string {
 		const replacer = (match: string, name: string) => {
-			let config = this.configurationService.getConfiguration<any>();
+			let config = this.configurationService.getConfiguration<any>({ resource: root.uri });
 			let newValue: any;
 			try {
 				const keys: string[] = name.split('.');
@@ -177,7 +195,7 @@ export class ConfigurationResolverService implements IConfigurationResolverServi
 		return value.replace(/\$\{config:(.+?)\}/g, replacer);
 	}
 
-	private resolveLiteral(root: uri, values: IStringDictionary<string | IStringDictionary<string> | string[]>): IStringDictionary<string | IStringDictionary<string> | string[]> {
+	private resolveLiteral(root: IWorkspaceFolder, values: IStringDictionary<string | IStringDictionary<string> | string[]>): IStringDictionary<string | IStringDictionary<string> | string[]> {
 		let result: IStringDictionary<string | IStringDictionary<string> | string[]> = Object.create(null);
 		Object.keys(values).forEach(key => {
 			let value = values[key];
@@ -186,8 +204,8 @@ export class ConfigurationResolverService implements IConfigurationResolverServi
 		return result;
 	}
 
-	private resolveAnyLiteral<T>(root: uri, values: T): T;
-	private resolveAnyLiteral<T>(root: uri, values: any): any {
+	private resolveAnyLiteral<T>(root: IWorkspaceFolder, values: T): T;
+	private resolveAnyLiteral<T>(root: IWorkspaceFolder, values: any): any {
 		let result: IStringDictionary<string | IStringDictionary<string> | string[]> = Object.create(null);
 		Object.keys(values).forEach(key => {
 			let value = values[key];
@@ -196,12 +214,12 @@ export class ConfigurationResolverService implements IConfigurationResolverServi
 		return result;
 	}
 
-	private resolveArray(root: uri, value: string[]): string[] {
+	private resolveArray(root: IWorkspaceFolder, value: string[]): string[] {
 		return value.map(s => this.resolveString(root, s));
 	}
 
-	private resolveAnyArray<T>(root: uri, value: T[]): T[];
-	private resolveAnyArray(root: uri, value: any[]): any[] {
+	private resolveAnyArray<T>(root: IWorkspaceFolder, value: T[]): T[];
+	private resolveAnyArray(root: IWorkspaceFolder, value: any[]): any[] {
 		return value.map(s => this.resolveAny(root, s));
 	}
 

src/vs/workbench/services/configurationResolver/test/node/configurationResolverService.test.ts

@@ -7,10 +7,11 @@ import assert = require('assert');
 import uri from 'vs/base/common/uri';
 import platform = require('vs/base/common/platform');
 import { TPromise } from 'vs/base/common/winjs.base';
-import { IConfigurationService, getConfigurationValue, IConfigurationOverrides, IConfigurationValue } from 'vs/platform/configuration/common/configuration';
+import { IConfigurationService, getConfigurationValue, IConfigurationOverrides } from 'vs/platform/configuration/common/configuration';
 import { ICommandService } from 'vs/platform/commands/common/commands';
 import { IConfigurationResolverService } from 'vs/workbench/services/configurationResolver/common/configurationResolver';
 import { ConfigurationResolverService } from 'vs/workbench/services/configurationResolver/node/configurationResolverService';
+import { IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
 import { TestEnvironmentService, TestEditorService } from 'vs/workbench/test/workbenchTestServices';
 import { TestConfigurationService } from 'vs/platform/configuration/test/common/testConfigurationService';
 
@@ -19,13 +20,18 @@ suite('Configuration Resolver Service', () => {
 	let envVariables: { [key: string]: string } = { key1: 'Value for Key1', key2: 'Value for Key2' };
 	let mockCommandService: MockCommandService;
 	let editorService: TestEditorService;
-	let workspaceUri: uri;
+	let workspace: IWorkspaceFolder;
 
 
 	setup(() => {
 		mockCommandService = new MockCommandService();
 		editorService = new TestEditorService();
-		workspaceUri = uri.parse('file:///VSCode/workspaceLocation');
+		workspace = {
+			uri: uri.parse('file:///VSCode/workspaceLocation'),
+			name: 'hey',
+			index: 0,
+			toResource: () => null
+		};
 		configurationResolverService = new ConfigurationResolverService(envVariables, editorService, TestEnvironmentService, new TestConfigurationService(), mockCommandService);
 	});
 
@@ -36,41 +42,41 @@ suite('Configuration Resolver Service', () => {
 
 	test('substitute one', () => {
 		if (platform.isWindows) {
-			assert.strictEqual(configurationResolverService.resolve(workspaceUri, 'abc ${workspaceRoot} xyz'), 'abc \\VSCode\\workspaceLocation xyz');
+			assert.strictEqual(configurationResolverService.resolve(workspace, 'abc ${workspaceFolder} xyz'), 'abc \\VSCode\\workspaceLocation xyz');
 		} else {
-			assert.strictEqual(configurationResolverService.resolve(workspaceUri, 'abc ${workspaceRoot} xyz'), 'abc /VSCode/workspaceLocation xyz');
+			assert.strictEqual(configurationResolverService.resolve(workspace, 'abc ${workspaceFolder} xyz'), 'abc /VSCode/workspaceLocation xyz');
 		}
 	});
 
 	test('workspace root folder name', () => {
-		assert.strictEqual(configurationResolverService.resolve(workspaceUri, 'abc ${workspaceRootFolderName} xyz'), 'abc workspaceLocation xyz');
+		assert.strictEqual(configurationResolverService.resolve(workspace, 'abc ${workspaceRootFolderName} xyz'), 'abc workspaceLocation xyz');
 	});
 
 	test('current selected line number', () => {
-		assert.strictEqual(configurationResolverService.resolve(workspaceUri, 'abc ${lineNumber} xyz'), `abc ${editorService.mockLineNumber} xyz`);
+		assert.strictEqual(configurationResolverService.resolve(workspace, 'abc ${lineNumber} xyz'), `abc ${editorService.mockLineNumber} xyz`);
 	});
 
 	test('substitute many', () => {
 		if (platform.isWindows) {
-			assert.strictEqual(configurationResolverService.resolve(workspaceUri, '${workspaceRoot} - ${workspaceRoot}'), '\\VSCode\\workspaceLocation - \\VSCode\\workspaceLocation');
+			assert.strictEqual(configurationResolverService.resolve(workspace, '${workspaceFolder} - ${workspaceFolder}'), '\\VSCode\\workspaceLocation - \\VSCode\\workspaceLocation');
 		} else {
-			assert.strictEqual(configurationResolverService.resolve(workspaceUri, '${workspaceRoot} - ${workspaceRoot}'), '/VSCode/workspaceLocation - /VSCode/workspaceLocation');
+			assert.strictEqual(configurationResolverService.resolve(workspace, '${workspaceFolder} - ${workspaceFolder}'), '/VSCode/workspaceLocation - /VSCode/workspaceLocation');
 		}
 	});
 
 	test('substitute one env variable', () => {
 		if (platform.isWindows) {
-			assert.strictEqual(configurationResolverService.resolve(workspaceUri, 'abc ${workspaceRoot} ${env:key1} xyz'), 'abc \\VSCode\\workspaceLocation Value for Key1 xyz');
+			assert.strictEqual(configurationResolverService.resolve(workspace, 'abc ${workspaceFolder} ${env:key1} xyz'), 'abc \\VSCode\\workspaceLocation Value for Key1 xyz');
 		} else {
-			assert.strictEqual(configurationResolverService.resolve(workspaceUri, 'abc ${workspaceRoot} ${env:key1} xyz'), 'abc /VSCode/workspaceLocation Value for Key1 xyz');
+			assert.strictEqual(configurationResolverService.resolve(workspace, 'abc ${workspaceFolder} ${env:key1} xyz'), 'abc /VSCode/workspaceLocation Value for Key1 xyz');
 		}
 	});
 
 	test('substitute many env variable', () => {
 		if (platform.isWindows) {
-			assert.strictEqual(configurationResolverService.resolve(workspaceUri, '${workspaceRoot} - ${workspaceRoot} ${env:key1} - ${env:key2}'), '\\VSCode\\workspaceLocation - \\VSCode\\workspaceLocation Value for Key1 - Value for Key2');
+			assert.strictEqual(configurationResolverService.resolve(workspace, '${workspaceFolder} - ${workspaceFolder} ${env:key1} - ${env:key2}'), '\\VSCode\\workspaceLocation - \\VSCode\\workspaceLocation Value for Key1 - Value for Key2');
 		} else {
-			assert.strictEqual(configurationResolverService.resolve(workspaceUri, '${workspaceRoot} - ${workspaceRoot} ${env:key1} - ${env:key2}'), '/VSCode/workspaceLocation - /VSCode/workspaceLocation Value for Key1 - Value for Key2');
+			assert.strictEqual(configurationResolverService.resolve(workspace, '${workspaceFolder} - ${workspaceFolder} ${env:key1} - ${env:key2}'), '/VSCode/workspaceLocation - /VSCode/workspaceLocation Value for Key1 - Value for Key2');
 		}
 	});
 
@@ -88,7 +94,7 @@ suite('Configuration Resolver Service', () => {
 		});
 
 		let service = new ConfigurationResolverService(envVariables, new TestEditorService(), TestEnvironmentService, configurationService, mockCommandService);
-		assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:editor.fontFamily} xyz'), 'abc foo xyz');
+		assert.strictEqual(service.resolve(workspace, 'abc ${config:editor.fontFamily} xyz'), 'abc foo xyz');
 	});
 
 	test('substitute many configuration variables', () => {
@@ -105,14 +111,14 @@ suite('Configuration Resolver Service', () => {
 		});
 
 		let service = new ConfigurationResolverService(envVariables, new TestEditorService(), TestEnvironmentService, configurationService, mockCommandService);
-		assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:editor.fontFamily} ${config:terminal.integrated.fontFamily} xyz'), 'abc foo bar xyz');
+		assert.strictEqual(service.resolve(workspace, 'abc ${config:editor.fontFamily} ${config:terminal.integrated.fontFamily} xyz'), 'abc foo bar xyz');
 	});
 
 	test('substitute nested configuration variables', () => {
 		let configurationService: IConfigurationService;
 		configurationService = new MockConfigurationService({
 			editor: {
-				fontFamily: 'foo ${workspaceRoot} ${config:terminal.integrated.fontFamily}'
+				fontFamily: 'foo ${workspaceFolder} ${config:terminal.integrated.fontFamily}'
 			},
 			terminal: {
 				integrated: {
@@ -123,9 +129,9 @@ suite('Configuration Resolver Service', () => {
 
 		let service = new ConfigurationResolverService(envVariables, new TestEditorService(), TestEnvironmentService, configurationService, mockCommandService);
 		if (platform.isWindows) {
-			assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:editor.fontFamily} ${config:terminal.integrated.fontFamily} xyz'), 'abc foo \\VSCode\\workspaceLocation bar bar xyz');
+			assert.strictEqual(service.resolve(workspace, 'abc ${config:editor.fontFamily} ${config:terminal.integrated.fontFamily} xyz'), 'abc foo \\VSCode\\workspaceLocation bar bar xyz');
 		} else {
-			assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:editor.fontFamily} ${config:terminal.integrated.fontFamily} xyz'), 'abc foo /VSCode/workspaceLocation bar bar xyz');
+			assert.strictEqual(service.resolve(workspace, 'abc ${config:editor.fontFamily} ${config:terminal.integrated.fontFamily} xyz'), 'abc foo /VSCode/workspaceLocation bar bar xyz');
 		}
 	});
 
@@ -133,7 +139,7 @@ suite('Configuration Resolver Service', () => {
 		let configurationService: IConfigurationService;
 		configurationService = new MockConfigurationService({
 			editor: {
-				fontFamily: 'foo ${workspaceRoot} ${config:terminal.integrated.fontFamily} ${config:editor.fontFamily}'
+				fontFamily: 'foo ${workspaceFolder} ${config:terminal.integrated.fontFamily} ${config:editor.fontFamily}'
 			},
 			terminal: {
 				integrated: {
@@ -144,9 +150,9 @@ suite('Configuration Resolver Service', () => {
 
 		let service = new ConfigurationResolverService(envVariables, new TestEditorService(), TestEnvironmentService, configurationService, mockCommandService);
 		if (platform.isWindows) {
-			assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:editor.fontFamily} ${config:terminal.integrated.fontFamily} xyz'), 'abc foo \\VSCode\\workspaceLocation bar  bar xyz');
+			assert.strictEqual(service.resolve(workspace, 'abc ${config:editor.fontFamily} ${config:terminal.integrated.fontFamily} xyz'), 'abc foo \\VSCode\\workspaceLocation bar  bar xyz');
 		} else {
-			assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:editor.fontFamily} ${config:terminal.integrated.fontFamily} xyz'), 'abc foo /VSCode/workspaceLocation bar  bar xyz');
+			assert.strictEqual(service.resolve(workspace, 'abc ${config:editor.fontFamily} ${config:terminal.integrated.fontFamily} xyz'), 'abc foo /VSCode/workspaceLocation bar  bar xyz');
 		}
 	});
 
@@ -165,9 +171,9 @@ suite('Configuration Resolver Service', () => {
 
 		let service = new ConfigurationResolverService(envVariables, new TestEditorService(), TestEnvironmentService, configurationService, mockCommandService);
 		if (platform.isWindows) {
-			assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:editor.fontFamily} ${workspaceRoot} ${env:key1} xyz'), 'abc foo \\VSCode\\workspaceLocation Value for Key1 xyz');
+			assert.strictEqual(service.resolve(workspace, 'abc ${config:editor.fontFamily} ${workspaceFolder} ${env:key1} xyz'), 'abc foo \\VSCode\\workspaceLocation Value for Key1 xyz');
 		} else {
-			assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:editor.fontFamily} ${workspaceRoot} ${env:key1} xyz'), 'abc foo /VSCode/workspaceLocation Value for Key1 xyz');
+			assert.strictEqual(service.resolve(workspace, 'abc ${config:editor.fontFamily} ${workspaceFolder} ${env:key1} xyz'), 'abc foo /VSCode/workspaceLocation Value for Key1 xyz');
 		}
 	});
 
@@ -186,9 +192,9 @@ suite('Configuration Resolver Service', () => {
 
 		let service = new ConfigurationResolverService(envVariables, new TestEditorService(), TestEnvironmentService, configurationService, mockCommandService);
 		if (platform.isWindows) {
-			assert.strictEqual(service.resolve(workspaceUri, '${config:editor.fontFamily} ${config:terminal.integrated.fontFamily} ${workspaceRoot} - ${workspaceRoot} ${env:key1} - ${env:key2}'), 'foo bar \\VSCode\\workspaceLocation - \\VSCode\\workspaceLocation Value for Key1 - Value for Key2');
+			assert.strictEqual(service.resolve(workspace, '${config:editor.fontFamily} ${config:terminal.integrated.fontFamily} ${workspaceFolder} - ${workspaceFolder} ${env:key1} - ${env:key2}'), 'foo bar \\VSCode\\workspaceLocation - \\VSCode\\workspaceLocation Value for Key1 - Value for Key2');
 		} else {
-			assert.strictEqual(service.resolve(workspaceUri, '${config:editor.fontFamily} ${config:terminal.integrated.fontFamily} ${workspaceRoot} - ${workspaceRoot} ${env:key1} - ${env:key2}'), 'foo bar /VSCode/workspaceLocation - /VSCode/workspaceLocation Value for Key1 - Value for Key2');
+			assert.strictEqual(service.resolve(workspace, '${config:editor.fontFamily} ${config:terminal.integrated.fontFamily} ${workspaceFolder} - ${workspaceFolder} ${env:key1} - ${env:key2}'), 'foo bar /VSCode/workspaceLocation - /VSCode/workspaceLocation Value for Key1 - Value for Key2');
 		}
 	});
 
@@ -219,7 +225,7 @@ suite('Configuration Resolver Service', () => {
 		});
 
 		let service = new ConfigurationResolverService(envVariables, new TestEditorService(), TestEnvironmentService, configurationService, mockCommandService);
-		assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:editor.fontFamily} ${config:editor.lineNumbers} ${config:editor.insertSpaces} xyz'), 'abc foo 123 false xyz');
+		assert.strictEqual(service.resolve(workspace, 'abc ${config:editor.fontFamily} ${config:editor.lineNumbers} ${config:editor.insertSpaces} xyz'), 'abc foo 123 false xyz');
 	});
 
 	test('configuration should not evaluate Javascript', () => {
@@ -231,7 +237,7 @@ suite('Configuration Resolver Service', () => {
 		});
 
 		let service = new ConfigurationResolverService(envVariables, new TestEditorService(), TestEnvironmentService, configurationService, mockCommandService);
-		assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:editor[\'abc\'.substr(0)]} xyz'), 'abc  xyz');
+		assert.strictEqual(service.resolve(workspace, 'abc ${config:editor[\'abc\'.substr(0)]} xyz'), 'abc  xyz');
 	});
 
 	test('uses empty string as fallback', () => {
@@ -241,10 +247,10 @@ suite('Configuration Resolver Service', () => {
 		});
 
 		let service = new ConfigurationResolverService(envVariables, new TestEditorService(), TestEnvironmentService, configurationService, mockCommandService);
-		assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:editor.abc} xyz'), 'abc  xyz');
-		assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:editor.abc.def} xyz'), 'abc  xyz');
-		assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:panel} xyz'), 'abc  xyz');
-		assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:panel.abc} xyz'), 'abc  xyz');
+		assert.strictEqual(service.resolve(workspace, 'abc ${config:editor.abc} xyz'), 'abc  xyz');
+		assert.strictEqual(service.resolve(workspace, 'abc ${config:editor.abc.def} xyz'), 'abc  xyz');
+		assert.strictEqual(service.resolve(workspace, 'abc ${config:panel} xyz'), 'abc  xyz');
+		assert.strictEqual(service.resolve(workspace, 'abc ${config:panel.abc} xyz'), 'abc  xyz');
 	});
 
 	test('is restricted to own properties', () => {
@@ -254,8 +260,8 @@ suite('Configuration Resolver Service', () => {
 		});
 
 		let service = new ConfigurationResolverService(envVariables, new TestEditorService(), TestEnvironmentService, configurationService, mockCommandService);
-		assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:editor.__proto__} xyz'), 'abc  xyz');
-		assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:editor.toString} xyz'), 'abc  xyz');
+		assert.strictEqual(service.resolve(workspace, 'abc ${config:editor.__proto__} xyz'), 'abc  xyz');
+		assert.strictEqual(service.resolve(workspace, 'abc ${config:editor.toString} xyz'), 'abc  xyz');
 	});
 
 	test('configuration variables with invalid accessor', () => {
@@ -267,9 +273,9 @@ suite('Configuration Resolver Service', () => {
 		});
 
 		let service = new ConfigurationResolverService(envVariables, new TestEditorService(), TestEnvironmentService, configurationService, mockCommandService);
-		assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:} xyz'), 'abc ${config:} xyz');
-		assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:editor..fontFamily} xyz'), 'abc  xyz');
-		assert.strictEqual(service.resolve(workspaceUri, 'abc ${config:editor.none.none2} xyz'), 'abc  xyz');
+		assert.strictEqual(service.resolve(workspace, 'abc ${config:} xyz'), 'abc ${config:} xyz');
+		assert.strictEqual(service.resolve(workspace, 'abc ${config:editor..fontFamily} xyz'), 'abc  xyz');
+		assert.strictEqual(service.resolve(workspace, 'abc ${config:editor.none.none2} xyz'), 'abc  xyz');
 	});
 
 	test('interactive variable simple', () => {
@@ -342,13 +348,14 @@ class MockConfigurationService implements IConfigurationService {
 	public _serviceBrand: any;
 	public serviceId = IConfigurationService;
 	public constructor(private configuration: any = {}) { }
-	public reloadConfiguration<T>(section?: string): TPromise<T> { return TPromise.as(this.getConfiguration()); }
-	public lookup<T>(key: string, overrides?: IConfigurationOverrides): IConfigurationValue<T> { return { value: getConfigurationValue<T>(this.getConfiguration(), key), default: getConfigurationValue<T>(this.getConfiguration(), key), user: getConfigurationValue<T>(this.getConfiguration(), key), workspace: void 0, folder: void 0 }; }
-	public keys() { return { default: [], user: [], workspace: [], folder: [] }; }
-	public values() { return {}; }
+	public inspect<T>(key: string, overrides?: IConfigurationOverrides): any { return { value: getConfigurationValue<T>(this.getConfiguration(), key), default: getConfigurationValue<T>(this.getConfiguration(), key), user: getConfigurationValue<T>(this.getConfiguration(), key), workspaceFolder: void 0, folder: void 0 }; }
+	public keys() { return { default: [], user: [], workspace: [], workspaceFolder: [] }; }
 	public getConfiguration(): any { return this.configuration; }
+	public getValue(key: string): any { return getConfigurationValue<any>(this.getConfiguration(), key); }
+	public updateValue(): TPromise<void> { return null; }
 	public getConfigurationData(): any { return null; }
-	public onDidUpdateConfiguration() { return { dispose() { } }; }
+	public onDidChangeConfiguration() { return { dispose() { } }; }
+	public reloadConfiguration() { return null; }
 }
 
 class MockCommandService implements ICommandService {