Merge branch 'master' into master

build/builtInExtensions.json

@@ -16,7 +16,7 @@
 	},
 	{
 		"name": "ms-vscode.node-debug2",
-		"version": "1.39.2",
+		"version": "1.39.3",
 		"repo": "https://github.com/Microsoft/vscode-node-debug2",
 		"metadata": {
 			"id": "36d19e17-7569-4841-a001-947eb18602b2",

extensions/git/src/commands.ts

@@ -1336,7 +1336,7 @@ export class CommandCenter {
 
 			if (promptToSaveFilesBeforeCommit === 'staged' || repository.indexGroup.resourceStates.length > 0) {
 				documents = documents
-					.filter(d => repository.indexGroup.resourceStates.some(s => s.resourceUri.path === d.uri.fsPath));
+					.filter(d => repository.indexGroup.resourceStates.some(s => pathEquals(s.resourceUri.fsPath, d.uri.fsPath)));
 			}
 
 			if (documents.length > 0) {

extensions/json-language-features/client/src/jsonMain.ts

@@ -168,7 +168,11 @@ export function activate(context: ExtensionContext) {
 				return xhr({ url: uriPath, followRedirects: 5, headers }).then(response => {
 					return response.responseText;
 				}, (error: XHRResponse) => {
-					return Promise.reject(new ResponseError(error.status, error.responseText || getErrorStatusDescription(error.status) || error.toString()));
+					let extraInfo = error.responseText || error.toString();
+					if (extraInfo.length > 256) {
+						extraInfo = `${extraInfo.substr(0, 256)}...`;
+					}
+					return Promise.reject(new ResponseError(error.status, getErrorStatusDescription(error.status) + '\n' + extraInfo));
 				});
 			}
 		});

extensions/json-language-features/server/package.json

@@ -14,9 +14,9 @@
   "dependencies": {
     "jsonc-parser": "^2.2.0",
     "request-light": "^0.2.5",
-    "vscode-json-languageservice": "^3.4.1",
+    "vscode-json-languageservice": "^3.4.3",
     "vscode-languageserver": "^6.0.0-next.1",
-    "vscode-uri": "^2.0.3"
+    "vscode-uri": "^2.1.1"
   },
   "devDependencies": {
     "@types/mocha": "2.2.33",

extensions/typescript-language-features/src/features/documentSymbol.ts

@@ -25,6 +25,8 @@ const getSymbolKind = (kind: string): vscode.SymbolKind => {
 		case PConst.Kind.localVariable: return vscode.SymbolKind.Variable;
 		case PConst.Kind.function: return vscode.SymbolKind.Function;
 		case PConst.Kind.localFunction: return vscode.SymbolKind.Function;
+		case PConst.Kind.constructSignature: return vscode.SymbolKind.Constructor;
+		case PConst.Kind.constructorImplementation: return vscode.SymbolKind.Constructor;
 	}
 	return vscode.SymbolKind.Variable;
 };

extensions/vscode-api-tests/src/singlefolder-tests/terminal.test.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { window, Pseudoterminal, EventEmitter, TerminalDimensions, workspace, ConfigurationTarget } from 'vscode';
+import { window, Pseudoterminal, EventEmitter, TerminalDimensions, workspace, ConfigurationTarget, Disposable } from 'vscode';
 import { doesNotThrow, equal, ok, deepEqual } from 'assert';
 
 suite('window namespace tests', () => {
@@ -12,75 +12,91 @@ suite('window namespace tests', () => {
 		await workspace.getConfiguration('terminal.integrated').update('windowsEnableConpty', false, ConfigurationTarget.Global);
 	});
 	suite('Terminal', () => {
+		let disposables: Disposable[] = [];
+
+		teardown(() => {
+			disposables.forEach(d => d.dispose());
+			disposables.length = 0;
+		});
+
 		test('sendText immediately after createTerminal should not throw', (done) => {
-			const reg1 = window.onDidOpenTerminal(term => {
-				equal(terminal, term);
+			disposables.push(window.onDidOpenTerminal(term => {
+				try {
+					equal(terminal, term);
+				} catch (e) {
+					done(e);
+				}
 				terminal.dispose();
-				reg1.dispose();
-				const reg2 = window.onDidCloseTerminal(() => {
-					reg2.dispose();
-					done();
-				});
-			});
+				disposables.push(window.onDidCloseTerminal(() => done()));
+			}));
 			const terminal = window.createTerminal();
 			doesNotThrow(terminal.sendText.bind(terminal, 'echo "foo"'));
 		});
 
 		test('onDidCloseTerminal event fires when terminal is disposed', (done) => {
-			const reg1 = window.onDidOpenTerminal(term => {
-				equal(terminal, term);
+			disposables.push(window.onDidOpenTerminal(term => {
+				try {
+					equal(terminal, term);
+				} catch (e) {
+					done(e);
+				}
 				terminal.dispose();
-				reg1.dispose();
-				const reg2 = window.onDidCloseTerminal(() => {
-					reg2.dispose();
-					done();
-				});
-			});
+				disposables.push(window.onDidCloseTerminal(() => done()));
+			}));
 			const terminal = window.createTerminal();
 		});
 
 		test('processId immediately after createTerminal should fetch the pid', (done) => {
-			const reg1 = window.onDidOpenTerminal(term => {
-				equal(terminal, term);
-				reg1.dispose();
+			disposables.push(window.onDidOpenTerminal(term => {
+				try {
+					equal(terminal, term);
+				} catch (e) {
+					done(e);
+				}
 				terminal.processId.then(id => {
-					ok(id > 0);
+					try {
+						ok(id > 0);
+					} catch (e) {
+						done(e);
+					}
 					terminal.dispose();
-					const reg2 = window.onDidCloseTerminal(() => {
-						reg2.dispose();
-						done();
-					});
+					disposables.push(window.onDidCloseTerminal(() => done()));
 				});
-			});
+			}));
 			const terminal = window.createTerminal();
 		});
 
 		test('name in constructor should set terminal.name', (done) => {
-			const reg1 = window.onDidOpenTerminal(term => {
-				equal(terminal, term);
+			disposables.push(window.onDidOpenTerminal(term => {
+				try {
+					equal(terminal, term);
+				} catch (e) {
+					done(e);
+				}
 				terminal.dispose();
-				reg1.dispose();
-				const reg2 = window.onDidCloseTerminal(() => {
-					reg2.dispose();
-					done();
-				});
-			});
+				disposables.push(window.onDidCloseTerminal(() => done()));
+			}));
 			const terminal = window.createTerminal('a');
-			equal(terminal.name, 'a');
+			try {
+				equal(terminal.name, 'a');
+			} catch (e) {
+				done(e);
+			}
 		});
 
 		test('onDidOpenTerminal should fire when a terminal is created', (done) => {
-			const reg1 = window.onDidOpenTerminal(term => {
-				equal(term.name, 'b');
-				reg1.dispose();
-				const reg2 = window.onDidCloseTerminal(() => {
-					reg2.dispose();
-					done();
-				});
+			disposables.push(window.onDidOpenTerminal(term => {
+				try {
+					equal(term.name, 'b');
+				} catch (e) {
+					done(e);
+				}
+				disposables.push(window.onDidCloseTerminal(() => done()));
 				terminal.dispose();
-			});
+			}));
 			const terminal = window.createTerminal('b');
 		});
+
 		// test('onDidChangeActiveTerminal should fire when new terminals are created', (done) => {
 		// 	const reg1 = window.onDidChangeActiveTerminal((active: Terminal | undefined) => {
 		// 		equal(active, terminal);
@@ -154,16 +170,20 @@ suite('window namespace tests', () => {
 		suite('hideFromUser', () => {
 			test('should be available to terminals API', done => {
 				const terminal = window.createTerminal({ name: 'bg', hideFromUser: true });
-				window.onDidOpenTerminal(t => {
-					equal(t, terminal);
-					equal(t.name, 'bg');
-					ok(window.terminals.indexOf(terminal) !== -1);
-					const reg3 = window.onDidCloseTerminal(() => {
-						reg3.dispose();
+				disposables.push(window.onDidOpenTerminal(t => {
+					try {
+						equal(t, terminal);
+						equal(t.name, 'bg');
+						ok(window.terminals.indexOf(terminal) !== -1);
+					} catch (e) {
+						done(e);
+					}
+					disposables.push(window.onDidCloseTerminal(() => {
+						// reg3.dispose();
 						done();
-					});
+					}));
 					terminal.dispose();
-				});
+				}));
 			});
 		});
 
@@ -172,32 +192,34 @@ suite('window namespace tests', () => {
 				const openEvents: string[] = [];
 				const dataEvents: { name: string, data: string }[] = [];
 				const closeEvents: string[] = [];
-				const reg1 = window.onDidOpenTerminal(e => openEvents.push(e.name));
+				disposables.push(window.onDidOpenTerminal(e => openEvents.push(e.name)));
 
 				let resolveOnceDataWritten: (() => void) | undefined;
 				let resolveOnceClosed: (() => void) | undefined;
 
-				const reg2 = window.onDidWriteTerminalData(e => {
+				disposables.push(window.onDidWriteTerminalData(e => {
 					dataEvents.push({ name: e.terminal.name, data: e.data });
 
 					resolveOnceDataWritten!();
-				});
+				}));
 
-				const reg3 = window.onDidCloseTerminal(e => {
+				disposables.push(window.onDidCloseTerminal(e => {
 					closeEvents.push(e.name);
-
-					if (closeEvents.length === 1) {
-						deepEqual(openEvents, ['test1']);
-						deepEqual(dataEvents, [{ name: 'test1', data: 'write1' }]);
-						deepEqual(closeEvents, ['test1']);
-						resolveOnceClosed!();
-					} else if (closeEvents.length === 2) {
-						deepEqual(openEvents, ['test1', 'test2']);
-						deepEqual(dataEvents, [{ name: 'test1', data: 'write1' }, { name: 'test2', data: 'write2' }]);
-						deepEqual(closeEvents, ['test1', 'test2']);
+					try {
+						if (closeEvents.length === 1) {
+							deepEqual(openEvents, ['test1']);
+							deepEqual(dataEvents, [{ name: 'test1', data: 'write1' }]);
+							deepEqual(closeEvents, ['test1']);
+						} else if (closeEvents.length === 2) {
+							deepEqual(openEvents, ['test1', 'test2']);
+							deepEqual(dataEvents, [{ name: 'test1', data: 'write1' }, { name: 'test2', data: 'write2' }]);
+							deepEqual(closeEvents, ['test1', 'test2']);
+						}
 						resolveOnceClosed!();
+					} catch (e) {
+						done(e);
 					}
-				});
+				}));
 
 				const term1Write = new EventEmitter<string>();
 				const term1Close = new EventEmitter<void>();
@@ -233,9 +255,6 @@ suite('window namespace tests', () => {
 										// Wait until the terminal is closed
 										await new Promise<void>(resolve => { resolveOnceClosed = resolve; });
 
-										reg1.dispose();
-										reg2.dispose();
-										reg3.dispose();
 										done();
 									},
 									close: () => { }
@@ -250,15 +269,15 @@ suite('window namespace tests', () => {
 
 		suite('Extension pty terminals', () => {
 			test('should fire onDidOpenTerminal and onDidCloseTerminal', (done) => {
-				const reg1 = window.onDidOpenTerminal(term => {
-					equal(term.name, 'c');
-					reg1.dispose();
-					const reg2 = window.onDidCloseTerminal(() => {
-						reg2.dispose();
-						done();
-					});
+				disposables.push(window.onDidOpenTerminal(term => {
+					try {
+						equal(term.name, 'c');
+					} catch (e) {
+						done(e);
+					}
+					disposables.push(window.onDidCloseTerminal(() => done()));
 					term.dispose();
-				});
+				}));
 				const pty: Pseudoterminal = {
 					onDidWrite: new EventEmitter<string>().event,
 					open: () => { },
@@ -315,22 +334,29 @@ suite('window namespace tests', () => {
 			// });
 
 			test('should respect dimension overrides', (done) => {
-				const reg1 = window.onDidOpenTerminal(term => {
-					equal(terminal, term);
-					reg1.dispose();
+				disposables.push(window.onDidOpenTerminal(term => {
+					try {
+						equal(terminal, term);
+					} catch (e) {
+						done(e);
+					}
 					term.show();
-					const reg2 = window.onDidChangeTerminalDimensions(e => {
-						equal(e.dimensions.columns, 10);
-						equal(e.dimensions.rows, 5);
-						equal(e.terminal, terminal);
-						reg2.dispose();
-						const reg3 = window.onDidCloseTerminal(() => {
-							reg3.dispose();
-							done();
-						});
+					disposables.push(window.onDidChangeTerminalDimensions(e => {
+						if (e.dimensions.columns === 0 || e.dimensions.rows === 0) {
+							// HACK: Ignore the event if dimension(s) are zero (#83778)
+							return;
+						}
+						try {
+							equal(e.dimensions.columns, 10);
+							equal(e.dimensions.rows, 5);
+							equal(e.terminal, terminal);
+						} catch (e) {
+							done(e);
+						}
+						disposables.push(window.onDidCloseTerminal(() => done()));
 						terminal.dispose();
-					});
-				});
+					}));
+				}));
 				const writeEmitter = new EventEmitter<string>();
 				const overrideDimensionsEmitter = new EventEmitter<TerminalDimensions>();
 				const pty: Pseudoterminal = {

extensions/vscode-api-tests/src/singlefolder-tests/workspace.tasks.test.ts

@@ -4,14 +4,20 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as assert from 'assert';
-import * as vscode from 'vscode';
+import { window, tasks, Disposable, TaskDefinition, Task, EventEmitter, CustomExecution, Pseudoterminal, TaskScope, commands, Task2 } from 'vscode';
 
 suite('workspace-namespace', () => {
 
 	suite('Tasks', () => {
+		let disposables: Disposable[] = [];
+
+		teardown(() => {
+			disposables.forEach(d => d.dispose());
+			disposables.length = 0;
+		});
 
 		test('CustomExecution task should start and shutdown successfully', (done) => {
-			interface CustomTestingTaskDefinition extends vscode.TaskDefinition {
+			interface CustomTestingTaskDefinition extends TaskDefinition {
 				/**
 				 * One of the task properties. This can be used to customize the task in the tasks.json
 				 */
@@ -19,45 +25,58 @@ suite('workspace-namespace', () => {
 			}
 			const taskType: string = 'customTesting';
 			const taskName = 'First custom task';
-			const reg1 = vscode.window.onDidOpenTerminal(term => {
-				reg1.dispose();
-				const reg2 = vscode.window.onDidWriteTerminalData(e => {
-					reg2.dispose();
-					assert.equal(e.data, 'testing\r\n');
+			let isPseudoterminalClosed = false;
+			disposables.push(window.onDidOpenTerminal(term => {
+				disposables.push(window.onDidWriteTerminalData(e => {
+					try {
+						assert.equal(e.data, 'testing\r\n');
+					} catch (e) {
+						done(e);
+					}
+					disposables.push(window.onDidCloseTerminal(() => {
+						try {
+							// Pseudoterminal.close should have fired by now, additionally we want
+							// to make sure all events are flushed before continuing with more tests
+							assert.ok(isPseudoterminalClosed);
+						} catch (e) {
+							done(e);
+							return;
+						}
+						done();
+					}));
 					term.dispose();
-				});
-			});
-			const taskProvider = vscode.tasks.registerTaskProvider(taskType, {
+				}));
+			}));
+			disposables.push(tasks.registerTaskProvider(taskType, {
 				provideTasks: () => {
-					const result: vscode.Task[] = [];
+					const result: Task[] = [];
 					const kind: CustomTestingTaskDefinition = {
 						type: taskType,
 						customProp1: 'testing task one'
 					};
-					const writeEmitter = new vscode.EventEmitter<string>();
-					const execution = new vscode.CustomExecution((): Thenable<vscode.Pseudoterminal> => {
-						const pty: vscode.Pseudoterminal = {
+					const writeEmitter = new EventEmitter<string>();
+					const execution = new CustomExecution((): Thenable<Pseudoterminal> => {
+						const pty: Pseudoterminal = {
 							onDidWrite: writeEmitter.event,
-							open: () => {
-								writeEmitter.fire('testing\r\n');
-							},
-							close: () => {
-								taskProvider.dispose();
-								done();
-							}
+							open: () => writeEmitter.fire('testing\r\n'),
+							close: () => isPseudoterminalClosed = true
 						};
 						return Promise.resolve(pty);
 					});
-					const task = new vscode.Task2(kind, vscode.TaskScope.Workspace, taskName, taskType, execution);
+					const task = new Task2(kind, TaskScope.Workspace, taskName, taskType, execution);
 					result.push(task);
 					return result;
 				},
-				resolveTask(_task: vscode.Task): vscode.Task | undefined {
+				resolveTask(_task: Task): Task | undefined {
+					try {
 					assert.fail('resolveTask should not trigger during the test');
+					} catch (e) {
+						done(e);
+					}
 					return undefined;
 				}
-			});
-			vscode.commands.executeCommand('workbench.action.tasks.runTask', `${taskType}: ${taskName}`);
+			}));
+			commands.executeCommand('workbench.action.tasks.runTask', `${taskType}: ${taskName}`);
 		});
 	});
 });

src/vs/base/browser/ui/tree/abstractTree.ts

@@ -7,7 +7,7 @@ import 'vs/css!./media/tree';
 import { IDisposable, dispose, Disposable, toDisposable, DisposableStore } from 'vs/base/common/lifecycle';
 import { IListOptions, List, IListStyles, MouseController, DefaultKeyboardNavigationDelegate } from 'vs/base/browser/ui/list/listWidget';
 import { IListVirtualDelegate, IListRenderer, IListMouseEvent, IListEvent, IListContextMenuEvent, IListDragAndDrop, IListDragOverReaction, IKeyboardNavigationLabelProvider, IIdentityProvider, IKeyboardNavigationDelegate } from 'vs/base/browser/ui/list/list';
-import { append, $, toggleClass, getDomNodePagePosition, removeClass, addClass, hasClass, hasParentWithClass, createStyleSheet, clearNode } from 'vs/base/browser/dom';
+import { append, $, toggleClass, getDomNodePagePosition, removeClass, addClass, hasClass, hasParentWithClass, createStyleSheet, clearNode, addClasses, removeClasses } from 'vs/base/browser/dom';
 import { Event, Relay, Emitter, EventBufferer } from 'vs/base/common/event';
 import { StandardKeyboardEvent } from 'vs/base/browser/keyboardEvent';
 import { KeyCode } from 'vs/base/common/keyCodes';
@@ -211,6 +211,8 @@ export enum RenderIndentGuides {
 interface ITreeRendererOptions {
 	readonly indent?: number;
 	readonly renderIndentGuides?: RenderIndentGuides;
+	// TODO@joao replace this with collapsible: boolean | 'ondemand'
+	readonly hideTwistiesOfChildlessElements?: boolean;
 }
 
 interface IRenderData<TTemplateData> {
@@ -244,6 +246,7 @@ class TreeRenderer<T, TFilterData, TRef, TTemplateData> implements IListRenderer
 	private renderedElements = new Map<T, ITreeNode<T, TFilterData>>();
 	private renderedNodes = new Map<ITreeNode<T, TFilterData>, IRenderData<TTemplateData>>();
 	private indent: number = TreeRenderer.DefaultIndent;
+	private hideTwistiesOfChildlessElements: boolean = false;
 
 	private shouldRenderIndentGuides: boolean = false;
 	private renderedIndentGuides = new SetMap<ITreeNode<T, TFilterData>, HTMLDivElement>();
@@ -290,6 +293,10 @@ class TreeRenderer<T, TFilterData, TRef, TTemplateData> implements IListRenderer
 				}
 			}
 		}
+
+		if (typeof options.hideTwistiesOfChildlessElements !== 'undefined') {
+			this.hideTwistiesOfChildlessElements = options.hideTwistiesOfChildlessElements;
+		}
 	}
 
 	renderTemplate(container: HTMLElement): ITreeListTemplateData<TTemplateData> {
@@ -365,10 +372,12 @@ class TreeRenderer<T, TFilterData, TRef, TTemplateData> implements IListRenderer
 			this.renderer.renderTwistie(node.element, templateData.twistie);
 		}
 
-		toggleClass(templateData.twistie, 'codicon', node.collapsible);
-		toggleClass(templateData.twistie, 'codicon-chevron-down', node.collapsible);
-		toggleClass(templateData.twistie, 'collapsible', node.collapsible);
-		toggleClass(templateData.twistie, 'collapsed', node.collapsible && node.collapsed);
+		if (node.collapsible && (!this.hideTwistiesOfChildlessElements || node.visibleChildrenCount > 0)) {
+			addClasses(templateData.twistie, 'codicon', 'codicon-chevron-down', 'collapsible');
+			toggleClass(templateData.twistie, 'collapsed', node.collapsed);
+		} else {
+			removeClasses(templateData.twistie, 'codicon', 'codicon-chevron-down', 'collapsible', 'collapsed');
+		}
 
 		if (node.collapsible) {
 			templateData.container.setAttribute('aria-expanded', String(!node.collapsed));

src/vs/base/browser/ui/tree/dataTree.ts

@@ -11,7 +11,7 @@ import { IListVirtualDelegate, IIdentityProvider } from 'vs/base/browser/ui/list
 import { Iterator } from 'vs/base/common/iterator';
 
 export interface IDataTreeOptions<T, TFilterData = void> extends IAbstractTreeOptions<T, TFilterData> {
-	sorter?: ITreeSorter<T>;
+	readonly sorter?: ITreeSorter<T>;
 }
 
 export interface IDataTreeViewState {

src/vs/editor/common/config/commonEditorConfig.ts

@@ -15,6 +15,7 @@ import * as editorCommon from 'vs/editor/common/editorCommon';
 import { ConfigurationScope, Extensions, IConfigurationNode, IConfigurationRegistry, IConfigurationPropertySchema } from 'vs/platform/configuration/common/configurationRegistry';
 import { Registry } from 'vs/platform/registry/common/platform';
 import { AccessibilitySupport } from 'vs/platform/accessibility/common/accessibility';
+import { forEach } from 'vs/base/common/collections';
 
 /**
  * Control what pressing Tab does.
@@ -197,6 +198,43 @@ function migrateOptions(options: IEditorOptions): void {
 		options.tabCompletion = 'onlySnippets';
 	}
 
+	const suggest = options.suggest;
+	if (suggest && typeof (<any>suggest).filteredTypes === 'object' && (<any>suggest).filteredTypes) {
+		const mapping: Record<string, string> = {};
+		mapping['method'] = 'showMethods';
+		mapping['function'] = 'showFunctions';
+		mapping['constructor'] = 'showConstructors';
+		mapping['field'] = 'showFields';
+		mapping['variable'] = 'showVariables';
+		mapping['class'] = 'showClasses';
+		mapping['struct'] = 'showStructs';
+		mapping['interface'] = 'showInterfaces';
+		mapping['module'] = 'showModules';
+		mapping['property'] = 'showProperties';
+		mapping['event'] = 'showEvents';
+		mapping['operator'] = 'showOperators';
+		mapping['unit'] = 'showUnits';
+		mapping['value'] = 'showValues';
+		mapping['constant'] = 'showConstants';
+		mapping['enum'] = 'showEnums';
+		mapping['enumMember'] = 'showEnumMembers';
+		mapping['keyword'] = 'showKeywords';
+		mapping['text'] = 'showWords';
+		mapping['color'] = 'showColors';
+		mapping['file'] = 'showFiles';
+		mapping['reference'] = 'showReferences';
+		mapping['folder'] = 'showFolders';
+		mapping['typeParameter'] = 'showTypeParameters';
+		mapping['snippet'] = 'showSnippets';
+		forEach(mapping, entry => {
+			const value = (<any>suggest).filteredTypes[entry.key];
+			if (value === false) {
+				(<any>suggest)[entry.value] = value;
+			}
+		});
+		// delete (<any>suggest).filteredTypes;
+	}
+
 	const hover = options.hover;
 	if (<any>hover === true) {
 		options.hover = {

src/vs/editor/common/config/editorOptions.ts

@@ -10,7 +10,6 @@ import { FontInfo } from 'vs/editor/common/config/fontInfo';
 import { Constants } from 'vs/base/common/uint';
 import { USUAL_WORD_SEPARATORS } from 'vs/editor/common/model/wordHelper';
 import { AccessibilitySupport } from 'vs/platform/accessibility/common/accessibility';
-import { isObject } from 'vs/base/common/types';
 import { IConfigurationPropertySchema } from 'vs/platform/configuration/common/configurationRegistry';
 import { IDimension } from 'vs/editor/common/editorCommon';
 
@@ -2332,9 +2331,105 @@ export interface ISuggestOptions {
 	 */
 	maxVisibleSuggestions?: number;
 	/**
-	 * Names of suggestion types to filter.
+	 * Show method-suggestions.
 	 */
-	filteredTypes?: Record<string, boolean>;
+	showMethods?: boolean;
+	/**
+	 * Show function-suggestions.
+	 */
+	showFunctions?: boolean;
+	/**
+	 * Show constructor-suggestions.
+	 */
+	showConstructors?: boolean;
+	/**
+	 * Show field-suggestions.
+	 */
+	showFields?: boolean;
+	/**
+	 * Show variable-suggestions.
+	 */
+	showVariables?: boolean;
+	/**
+	 * Show class-suggestions.
+	 */
+	showClasses?: boolean;
+	/**
+	 * Show struct-suggestions.
+	 */
+	showStructs?: boolean;
+	/**
+	 * Show interface-suggestions.
+	 */
+	showInterfaces?: boolean;
+	/**
+	 * Show module-suggestions.
+	 */
+	showModules?: boolean;
+	/**
+	 * Show property-suggestions.
+	 */
+	showProperties?: boolean;
+	/**
+	 * Show event-suggestions.
+	 */
+	showEvents?: boolean;
+	/**
+	 * Show operator-suggestions.
+	 */
+	showOperators?: boolean;
+	/**
+	 * Show unit-suggestions.
+	 */
+	showUnits?: boolean;
+	/**
+	 * Show value-suggestions.
+	 */
+	showValues?: boolean;
+	/**
+	 * Show constant-suggestions.
+	 */
+	showConstants?: boolean;
+	/**
+	 * Show enum-suggestions.
+	 */
+	showEnums?: boolean;
+	/**
+	 * Show enumMember-suggestions.
+	 */
+	showEnumMembers?: boolean;
+	/**
+	 * Show keyword-suggestions.
+	 */
+	showKeywords?: boolean;
+	/**
+	 * Show text-suggestions.
+	 */
+	showWords?: boolean;
+	/**
+	 * Show color-suggestions.
+	 */
+	showColors?: boolean;
+	/**
+	 * Show file-suggestions.
+	 */
+	showFiles?: boolean;
+	/**
+	 * Show reference-suggestions.
+	 */
+	showReferences?: boolean;
+	/**
+	 * Show folder-suggestions.
+	 */
+	showFolders?: boolean;
+	/**
+	 * Show typeParameter-suggestions.
+	 */
+	showTypeParameters?: boolean;
+	/**
+	 * Show snippet-suggestions.
+	 */
+	showSnippets?: boolean;
 }
 
 export type InternalSuggestOptions = Readonly<Required<ISuggestOptions>>;
@@ -2350,7 +2445,31 @@ class EditorSuggest extends BaseEditorOption<EditorOption.suggest, InternalSugge
 			shareSuggestSelections: false,
 			showIcons: true,
 			maxVisibleSuggestions: 12,
-			filteredTypes: Object.create(null)
+			showMethods: true,
+			showFunctions: true,
+			showConstructors: true,
+			showFields: true,
+			showVariables: true,
+			showClasses: true,
+			showStructs: true,
+			showInterfaces: true,
+			showModules: true,
+			showProperties: true,
+			showEvents: true,
+			showOperators: true,
+			showUnits: true,
+			showValues: true,
+			showConstants: true,
+			showEnums: true,
+			showEnumMembers: true,
+			showKeywords: true,
+			showWords: true,
+			showColors: true,
+			showFiles: true,
+			showReferences: true,
+			showFolders: true,
+			showTypeParameters: true,
+			showSnippets: true,
 		};
 		super(
 			EditorOption.suggest, 'suggest', defaults,
@@ -2392,135 +2511,139 @@ class EditorSuggest extends BaseEditorOption<EditorOption.suggest, InternalSugge
 					maximum: 15,
 					description: nls.localize('suggest.maxVisibleSuggestions', "Controls how many suggestions IntelliSense will show before showing a scrollbar (maximum 15).")
 				},
-				'editor.suggest.filteredTypes.method': {
+				'editor.suggest.filteredTypes': {
+					type: 'object',
+					deprecationMessage: nls.localize('deprecated', "This setting is deprecated, please use separate settings like 'editor.suggest.showKeywords' or 'editor.suggest.showSnippets' instead.")
+				},
+				'editor.suggest.showMethods': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.method', "When enabled IntelliSense shows `method`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showMethods', "When enabled IntelliSense shows `method`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.function': {
+				'editor.suggest.showFunctions': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.function', "When enabled IntelliSense shows `function`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showFunctions', "When enabled IntelliSense shows `function`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.constructor': {
+				'editor.suggest.showConstructors': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.constructor', "When enabled IntelliSense shows `constructor`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showConstructors', "When enabled IntelliSense shows `constructor`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.field': {
+				'editor.suggest.showFields': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.field', "When enabled IntelliSense shows `field`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showFields', "When enabled IntelliSense shows `field`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.variable': {
+				'editor.suggest.showVariables': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.variable', "When enabled IntelliSense shows `variable`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showVariables', "When enabled IntelliSense shows `variable`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.class': {
+				'editor.suggest.showClasses': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.class', "When enabled IntelliSense shows `class`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showClasss', "When enabled IntelliSense shows `class`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.struct': {
+				'editor.suggest.showStructs': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.struct', "When enabled IntelliSense shows `struct`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showStructs', "When enabled IntelliSense shows `struct`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.interface': {
+				'editor.suggest.showInterfaces': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.interface', "When enabled IntelliSense shows `interface`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showInterfaces', "When enabled IntelliSense shows `interface`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.module': {
+				'editor.suggest.showModules': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.module', "When enabled IntelliSense shows `module`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showModules', "When enabled IntelliSense shows `module`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.property': {
+				'editor.suggest.showProperties': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.property', "When enabled IntelliSense shows `property`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showPropertys', "When enabled IntelliSense shows `property`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.event': {
+				'editor.suggest.showEvents': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.event', "When enabled IntelliSense shows `event`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showEvents', "When enabled IntelliSense shows `event`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.operator': {
+				'editor.suggest.showOperators': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.operator', "When enabled IntelliSense shows `operator`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showOperators', "When enabled IntelliSense shows `operator`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.unit': {
+				'editor.suggest.showUnits': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.unit', "When enabled IntelliSense shows `unit`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showUnits', "When enabled IntelliSense shows `unit`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.value': {
+				'editor.suggest.showValues': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.value', "When enabled IntelliSense shows `value`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showValues', "When enabled IntelliSense shows `value`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.constant': {
+				'editor.suggest.showConstants': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.constant', "When enabled IntelliSense shows `constant`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showConstants', "When enabled IntelliSense shows `constant`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.enum': {
+				'editor.suggest.showEnums': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.enum', "When enabled IntelliSense shows `enum`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showEnums', "When enabled IntelliSense shows `enum`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.enumMember': {
+				'editor.suggest.showEnumMembers': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.enumMember', "When enabled IntelliSense shows `enumMember`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showEnumMembers', "When enabled IntelliSense shows `enumMember`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.keyword': {
+				'editor.suggest.showKeywords': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.keyword', "When enabled IntelliSense shows `keyword`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showKeywords', "When enabled IntelliSense shows `keyword`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.text': {
+				'editor.suggest.showWords': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.text', "When enabled IntelliSense shows `text`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showTexts', "When enabled IntelliSense shows `text`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.color': {
+				'editor.suggest.showColors': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.color', "When enabled IntelliSense shows `color`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showColors', "When enabled IntelliSense shows `color`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.file': {
+				'editor.suggest.showFiles': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.file', "When enabled IntelliSense shows `file`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showFiles', "When enabled IntelliSense shows `file`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.reference': {
+				'editor.suggest.showReferences': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.reference', "When enabled IntelliSense shows `reference`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showReferences', "When enabled IntelliSense shows `reference`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.customcolor': {
+				'editor.suggest.showCustomcolors': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.customcolor', "When enabled IntelliSense shows `customcolor`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showCustomcolors', "When enabled IntelliSense shows `customcolor`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.folder': {
+				'editor.suggest.showFolders': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.folder', "When enabled IntelliSense shows `folder`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showFolders', "When enabled IntelliSense shows `folder`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.typeParameter': {
+				'editor.suggest.showTypeParameters': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.typeParameter', "When enabled IntelliSense shows `typeParameter`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showTypeParameters', "When enabled IntelliSense shows `typeParameter`-suggestions.")
 				},
-				'editor.suggest.filteredTypes.snippet': {
+				'editor.suggest.showSnippets': {
 					type: 'boolean',
 					default: true,
-					markdownDescription: nls.localize('suggest.filtered.snippet', "When enabled IntelliSense shows `snippet`-suggestions.")
+					markdownDescription: nls.localize('editor.suggest.showSnippets', "When enabled IntelliSense shows `snippet`-suggestions.")
 				},
 			}
 		);
@@ -2539,7 +2662,31 @@ class EditorSuggest extends BaseEditorOption<EditorOption.suggest, InternalSugge
 			shareSuggestSelections: EditorBooleanOption.boolean(input.shareSuggestSelections, this.defaultValue.shareSuggestSelections),
 			showIcons: EditorBooleanOption.boolean(input.showIcons, this.defaultValue.showIcons),
 			maxVisibleSuggestions: EditorIntOption.clampedInt(input.maxVisibleSuggestions, this.defaultValue.maxVisibleSuggestions, 1, 15),
-			filteredTypes: isObject(input.filteredTypes) ? input.filteredTypes : Object.create(null)
+			showMethods: EditorBooleanOption.boolean(input.showMethods, this.defaultValue.showMethods),
+			showFunctions: EditorBooleanOption.boolean(input.showFunctions, this.defaultValue.showFunctions),
+			showConstructors: EditorBooleanOption.boolean(input.showConstructors, this.defaultValue.showConstructors),
+			showFields: EditorBooleanOption.boolean(input.showFields, this.defaultValue.showFields),
+			showVariables: EditorBooleanOption.boolean(input.showVariables, this.defaultValue.showVariables),
+			showClasses: EditorBooleanOption.boolean(input.showClasses, this.defaultValue.showClasses),
+			showStructs: EditorBooleanOption.boolean(input.showStructs, this.defaultValue.showStructs),
+			showInterfaces: EditorBooleanOption.boolean(input.showInterfaces, this.defaultValue.showInterfaces),
+			showModules: EditorBooleanOption.boolean(input.showModules, this.defaultValue.showModules),
+			showProperties: EditorBooleanOption.boolean(input.showProperties, this.defaultValue.showProperties),
+			showEvents: EditorBooleanOption.boolean(input.showEvents, this.defaultValue.showEvents),
+			showOperators: EditorBooleanOption.boolean(input.showOperators, this.defaultValue.showOperators),
+			showUnits: EditorBooleanOption.boolean(input.showUnits, this.defaultValue.showUnits),
+			showValues: EditorBooleanOption.boolean(input.showValues, this.defaultValue.showValues),
+			showConstants: EditorBooleanOption.boolean(input.showConstants, this.defaultValue.showConstants),
+			showEnums: EditorBooleanOption.boolean(input.showEnums, this.defaultValue.showEnums),
+			showEnumMembers: EditorBooleanOption.boolean(input.showEnumMembers, this.defaultValue.showEnumMembers),
+			showKeywords: EditorBooleanOption.boolean(input.showKeywords, this.defaultValue.showKeywords),
+			showWords: EditorBooleanOption.boolean(input.showWords, this.defaultValue.showWords),
+			showColors: EditorBooleanOption.boolean(input.showColors, this.defaultValue.showColors),
+			showFiles: EditorBooleanOption.boolean(input.showFiles, this.defaultValue.showFiles),
+			showReferences: EditorBooleanOption.boolean(input.showReferences, this.defaultValue.showReferences),
+			showFolders: EditorBooleanOption.boolean(input.showFolders, this.defaultValue.showFolders),
+			showTypeParameters: EditorBooleanOption.boolean(input.showTypeParameters, this.defaultValue.showTypeParameters),
+			showSnippets: EditorBooleanOption.boolean(input.showSnippets, this.defaultValue.showSnippets),
 		};
 	}
 }

src/vs/editor/common/modes.ts

@@ -19,7 +19,6 @@ import { LanguageFeatureRegistry } from 'vs/editor/common/modes/languageFeatureR
 import { TokenizationRegistryImpl } from 'vs/editor/common/modes/tokenizationRegistry';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
 import { IMarkerData } from 'vs/platform/markers/common/markers';
-import { keys } from 'vs/base/common/map';
 
 /**
  * Open ended enum at runtime
@@ -938,12 +937,6 @@ export namespace SymbolKinds {
 	export function fromString(value: string): SymbolKind | undefined {
 		return byName.get(value);
 	}
-	/**
-	 * @internal
-	 */
-	export function names(): readonly string[] {
-		return keys(byName);
-	}
 	/**
 	 * @internal
 	 */

src/vs/editor/contrib/documentSymbols/outlineTree.ts

@@ -7,7 +7,7 @@ import * as dom from 'vs/base/browser/dom';
 import { HighlightedLabel } from 'vs/base/browser/ui/highlightedlabel/highlightedLabel';
 import { IIdentityProvider, IKeyboardNavigationLabelProvider, IListVirtualDelegate } from 'vs/base/browser/ui/list/list';
 import { IDataSource, ITreeNode, ITreeRenderer, ITreeSorter, ITreeFilter } from 'vs/base/browser/ui/tree/tree';
-import { values } from 'vs/base/common/collections';
+import { values, forEach } from 'vs/base/common/collections';
 import { createMatches, FuzzyScore } from 'vs/base/common/filters';
 import 'vs/css!./media/outlineTree';
 import 'vs/css!./media/symbol-icons';
@@ -220,6 +220,64 @@ export const enum OutlineSortOrder {
 
 export class OutlineFilter implements ITreeFilter<OutlineItem> {
 
+	static readonly configNameToKind = Object.freeze({
+		['showFiles']: SymbolKind.File,
+		['showModules']: SymbolKind.Module,
+		['showNamespaces']: SymbolKind.Namespace,
+		['showPackages']: SymbolKind.Package,
+		['showClasses']: SymbolKind.Class,
+		['showMethods']: SymbolKind.Method,
+		['showProperties']: SymbolKind.Property,
+		['showFields']: SymbolKind.Field,
+		['showConstructors']: SymbolKind.Constructor,
+		['showEnums']: SymbolKind.Enum,
+		['showInterfaces']: SymbolKind.Interface,
+		['showFunctions']: SymbolKind.Function,
+		['showVariables']: SymbolKind.Variable,
+		['showConstants']: SymbolKind.Constant,
+		['showStrings']: SymbolKind.String,
+		['showNumbers']: SymbolKind.Number,
+		['showBooleans']: SymbolKind.Boolean,
+		['showArrays']: SymbolKind.Array,
+		['showObjects']: SymbolKind.Object,
+		['showKeys']: SymbolKind.Key,
+		['showNull']: SymbolKind.Null,
+		['showEnumMembers']: SymbolKind.EnumMember,
+		['showStructs']: SymbolKind.Struct,
+		['showEvents']: SymbolKind.Event,
+		['showOperators']: SymbolKind.Operator,
+		['showTypeParameters']: SymbolKind.TypeParameter,
+	});
+
+	static readonly kindToConfigName = Object.freeze({
+		[SymbolKind.File]: 'showFiles',
+		[SymbolKind.Module]: 'showModules',
+		[SymbolKind.Namespace]: 'showNamespaces',
+		[SymbolKind.Package]: 'showPackages',
+		[SymbolKind.Class]: 'showClasses',
+		[SymbolKind.Method]: 'showMethods',
+		[SymbolKind.Property]: 'showProperties',
+		[SymbolKind.Field]: 'showFields',
+		[SymbolKind.Constructor]: 'showConstructors',
+		[SymbolKind.Enum]: 'showEnums',
+		[SymbolKind.Interface]: 'showInterfaces',
+		[SymbolKind.Function]: 'showFunctions',
+		[SymbolKind.Variable]: 'showVariables',
+		[SymbolKind.Constant]: 'showConstants',
+		[SymbolKind.String]: 'showStrings',
+		[SymbolKind.Number]: 'showNumbers',
+		[SymbolKind.Boolean]: 'showBooleans',
+		[SymbolKind.Array]: 'showArrays',
+		[SymbolKind.Object]: 'showObjects',
+		[SymbolKind.Key]: 'showKeys',
+		[SymbolKind.Null]: 'showNull',
+		[SymbolKind.EnumMember]: 'showEnumMembers',
+		[SymbolKind.Struct]: 'showStructs',
+		[SymbolKind.Event]: 'showEvents',
+		[SymbolKind.Operator]: 'showOperators',
+		[SymbolKind.TypeParameter]: 'showTypeParameters',
+	});
+
 	private readonly _filteredTypes = new Set<SymbolKind>();
 
 	constructor(
@@ -231,11 +289,12 @@ export class OutlineFilter implements ITreeFilter<OutlineItem> {
 
 	update() {
 		this._filteredTypes.clear();
-		for (const name of SymbolKinds.names()) {
-			if (!this._configService.getValue<boolean>(`${this._prefix}.${name}`)) {
-				this._filteredTypes.add(SymbolKinds.fromString(name) || -1);
+		forEach(OutlineFilter.configNameToKind, entry => {
+			const key = `${this._prefix}.${entry.key}`;
+			if (this._configService.getValue<boolean>(key) === false) {
+				this._filteredTypes.add(entry.value);
 			}
-		}
+		});
 	}
 
 	filter(element: OutlineItem): boolean {

src/vs/editor/contrib/suggest/suggestModel.ts

@@ -13,7 +13,7 @@ import { CursorChangeReason, ICursorSelectionChangedEvent } from 'vs/editor/comm
 import { Position, IPosition } from 'vs/editor/common/core/position';
 import { Selection } from 'vs/editor/common/core/selection';
 import { ITextModel, IWordAtPosition } from 'vs/editor/common/model';
-import { CompletionItemProvider, StandardTokenType, CompletionContext, CompletionProviderRegistry, CompletionTriggerKind, CompletionItemKind, completionKindFromString } from 'vs/editor/common/modes';
+import { CompletionItemProvider, StandardTokenType, CompletionContext, CompletionProviderRegistry, CompletionTriggerKind, CompletionItemKind } from 'vs/editor/common/modes';
 import { CompletionModel } from './completionModel';
 import { CompletionItem, getSuggestionComparator, provideSuggestionItems, getSnippetSuggestSupport, SnippetSortOrder, CompletionOptions } from './suggest';
 import { SnippetController2 } from 'vs/editor/contrib/snippet/snippetController2';
@@ -388,9 +388,7 @@ export class SuggestModel implements IDisposable {
 		this._requestToken = new CancellationTokenSource();
 
 		// kind filter and snippet sort rules
-		const suggestOptions = this._editor.getOption(EditorOption.suggest);
 		const snippetSuggestions = this._editor.getOption(EditorOption.snippetSuggestions);
-		let itemKindFilter = new Set<CompletionItemKind>();
 		let snippetSortOrder = SnippetSortOrder.Inline;
 		switch (snippetSuggestions) {
 			case 'top':
@@ -403,19 +401,9 @@ export class SuggestModel implements IDisposable {
 			case 'bottom':
 				snippetSortOrder = SnippetSortOrder.Bottom;
 				break;
-			case 'none':
-				itemKindFilter.add(CompletionItemKind.Snippet);
-				break;
-		}
-
-		// kind filter
-		for (const key in suggestOptions.filteredTypes) {
-			const kind = completionKindFromString(key, true);
-			if (typeof kind !== 'undefined' && suggestOptions.filteredTypes[key] === false) {
-				itemKindFilter.add(kind);
-			}
 		}
 
+		let itemKindFilter = SuggestModel._createItemKindFilter(this._editor);
 		let wordDistance = WordDistance.create(this._editorWorker, this._editor);
 
 		let items = provideSuggestionItems(
@@ -467,6 +455,48 @@ export class SuggestModel implements IDisposable {
 		}).catch(onUnexpectedError);
 	}
 
+	private static _createItemKindFilter(editor: ICodeEditor): Set<CompletionItemKind> {
+		// kind filter and snippet sort rules
+		const result = new Set<CompletionItemKind>();
+
+		// snippet setting
+		const snippetSuggestions = editor.getOption(EditorOption.snippetSuggestions);
+		if (snippetSuggestions === 'none') {
+			result.add(CompletionItemKind.Snippet);
+		}
+
+		// type setting
+		const suggestOptions = editor.getOption(EditorOption.suggest);
+		if (!suggestOptions.showMethods) { result.add(CompletionItemKind.Method); }
+		if (!suggestOptions.showFunctions) { result.add(CompletionItemKind.Function); }
+		if (!suggestOptions.showConstructors) { result.add(CompletionItemKind.Constructor); }
+		if (!suggestOptions.showFields) { result.add(CompletionItemKind.Field); }
+		if (!suggestOptions.showVariables) { result.add(CompletionItemKind.Variable); }
+		if (!suggestOptions.showClasses) { result.add(CompletionItemKind.Class); }
+		if (!suggestOptions.showStructs) { result.add(CompletionItemKind.Struct); }
+		if (!suggestOptions.showInterfaces) { result.add(CompletionItemKind.Interface); }
+		if (!suggestOptions.showModules) { result.add(CompletionItemKind.Module); }
+		if (!suggestOptions.showProperties) { result.add(CompletionItemKind.Property); }
+		if (!suggestOptions.showEvents) { result.add(CompletionItemKind.Event); }
+		if (!suggestOptions.showOperators) { result.add(CompletionItemKind.Operator); }
+		if (!suggestOptions.showUnits) { result.add(CompletionItemKind.Unit); }
+		if (!suggestOptions.showValues) { result.add(CompletionItemKind.Value); }
+		if (!suggestOptions.showConstants) { result.add(CompletionItemKind.Constant); }
+		if (!suggestOptions.showEnums) { result.add(CompletionItemKind.Enum); }
+		if (!suggestOptions.showEnumMembers) { result.add(CompletionItemKind.EnumMember); }
+		if (!suggestOptions.showKeywords) { result.add(CompletionItemKind.Keyword); }
+		if (!suggestOptions.showWords) { result.add(CompletionItemKind.Text); }
+		if (!suggestOptions.showColors) { result.add(CompletionItemKind.Color); }
+		if (!suggestOptions.showFiles) { result.add(CompletionItemKind.File); }
+		if (!suggestOptions.showReferences) { result.add(CompletionItemKind.Reference); }
+		if (!suggestOptions.showColors) { result.add(CompletionItemKind.Customcolor); }
+		if (!suggestOptions.showFolders) { result.add(CompletionItemKind.Folder); }
+		if (!suggestOptions.showTypeParameters) { result.add(CompletionItemKind.TypeParameter); }
+		if (!suggestOptions.showSnippets) { result.add(CompletionItemKind.Snippet); }
+
+		return result;
+	}
+
 	private _onNewContext(ctx: LineContext): void {
 
 		if (!this._context) {

src/vs/editor/contrib/suggest/test/completionModel.test.ts

@@ -33,6 +33,40 @@ export function createSuggestItem(label: string, overwriteBefore: number, kind =
 }
 suite('CompletionModel', function () {
 
+	let defaultOptions = {
+		overwriteOnAccept: false,
+		snippetsPreventQuickSuggestions: true,
+		filterGraceful: true,
+		localityBonus: false,
+		shareSuggestSelections: false,
+		showIcons: true,
+		maxVisibleSuggestions: 12,
+		showMethods: true,
+		showFunctions: true,
+		showConstructors: true,
+		showFields: true,
+		showVariables: true,
+		showClasses: true,
+		showStructs: true,
+		showInterfaces: true,
+		showModules: true,
+		showProperties: true,
+		showEvents: true,
+		showOperators: true,
+		showUnits: true,
+		showValues: true,
+		showConstants: true,
+		showEnums: true,
+		showEnumMembers: true,
+		showKeywords: true,
+		showWords: true,
+		showColors: true,
+		showFiles: true,
+		showReferences: true,
+		showFolders: true,
+		showTypeParameters: true,
+		showSnippets: true,
+	};
 
 	let model: CompletionModel;
 
@@ -158,16 +192,7 @@ suite('CompletionModel', function () {
 		], 1, {
 			leadingLineContent: 's',
 			characterCountDelta: 0
-		}, WordDistance.None, {
-			overwriteOnAccept: false,
-			snippetsPreventQuickSuggestions: true,
-			filterGraceful: true,
-			localityBonus: false,
-			shareSuggestSelections: false,
-			showIcons: true,
-			maxVisibleSuggestions: 12,
-			filteredTypes: Object.create(null)
-		}, 'top');
+		}, WordDistance.None, defaultOptions, 'top');
 
 		assert.equal(model.items.length, 2);
 		const [a, b] = model.items;
@@ -186,16 +211,7 @@ suite('CompletionModel', function () {
 		], 1, {
 			leadingLineContent: 's',
 			characterCountDelta: 0
-		}, WordDistance.None, {
-			overwriteOnAccept: false,
-			snippetsPreventQuickSuggestions: true,
-			filterGraceful: true,
-			localityBonus: false,
-			shareSuggestSelections: false,
-			showIcons: true,
-			maxVisibleSuggestions: 12,
-			filteredTypes: Object.create(null)
-		}, 'bottom');
+		}, WordDistance.None, defaultOptions, 'bottom');
 
 		assert.equal(model.items.length, 2);
 		const [a, b] = model.items;
@@ -213,16 +229,7 @@ suite('CompletionModel', function () {
 		], 1, {
 			leadingLineContent: 's',
 			characterCountDelta: 0
-		}, WordDistance.None, {
-			overwriteOnAccept: false,
-			snippetsPreventQuickSuggestions: true,
-			filterGraceful: true,
-			localityBonus: false,
-			shareSuggestSelections: false,
-			showIcons: true,
-			maxVisibleSuggestions: 12,
-			filteredTypes: Object.create(null)
-		}, 'inline');
+		}, WordDistance.None, defaultOptions, 'inline');
 
 		assert.equal(model.items.length, 2);
 		const [a, b] = model.items;

src/vs/monaco.d.ts

@@ -3415,9 +3415,105 @@ declare namespace monaco.editor {
 		 */
 		maxVisibleSuggestions?: number;
 		/**
-		 * Names of suggestion types to filter.
+		 * Show method-suggestions.
 		 */
-		filteredTypes?: Record<string, boolean>;
+		showMethods?: boolean;
+		/**
+		 * Show function-suggestions.
+		 */
+		showFunctions?: boolean;
+		/**
+		 * Show constructor-suggestions.
+		 */
+		showConstructors?: boolean;
+		/**
+		 * Show field-suggestions.
+		 */
+		showFields?: boolean;
+		/**
+		 * Show variable-suggestions.
+		 */
+		showVariables?: boolean;
+		/**
+		 * Show class-suggestions.
+		 */
+		showClasses?: boolean;
+		/**
+		 * Show struct-suggestions.
+		 */
+		showStructs?: boolean;
+		/**
+		 * Show interface-suggestions.
+		 */
+		showInterfaces?: boolean;
+		/**
+		 * Show module-suggestions.
+		 */
+		showModules?: boolean;
+		/**
+		 * Show property-suggestions.
+		 */
+		showProperties?: boolean;
+		/**
+		 * Show event-suggestions.
+		 */
+		showEvents?: boolean;
+		/**
+		 * Show operator-suggestions.
+		 */
+		showOperators?: boolean;
+		/**
+		 * Show unit-suggestions.
+		 */
+		showUnits?: boolean;
+		/**
+		 * Show value-suggestions.
+		 */
+		showValues?: boolean;
+		/**
+		 * Show constant-suggestions.
+		 */
+		showConstants?: boolean;
+		/**
+		 * Show enum-suggestions.
+		 */
+		showEnums?: boolean;
+		/**
+		 * Show enumMember-suggestions.
+		 */
+		showEnumMembers?: boolean;
+		/**
+		 * Show keyword-suggestions.
+		 */
+		showKeywords?: boolean;
+		/**
+		 * Show text-suggestions.
+		 */
+		showWords?: boolean;
+		/**
+		 * Show color-suggestions.
+		 */
+		showColors?: boolean;
+		/**
+		 * Show file-suggestions.
+		 */
+		showFiles?: boolean;
+		/**
+		 * Show reference-suggestions.
+		 */
+		showReferences?: boolean;
+		/**
+		 * Show folder-suggestions.
+		 */
+		showFolders?: boolean;
+		/**
+		 * Show typeParameter-suggestions.
+		 */
+		showTypeParameters?: boolean;
+		/**
+		 * Show snippet-suggestions.
+		 */
+		showSnippets?: boolean;
 	}
 
 	export type InternalSuggestOptions = Readonly<Required<ISuggestOptions>>;

src/vs/platform/list/browser/listService.ts

@@ -954,6 +954,7 @@ function workbenchTreeDataPreamble<T, TFilterData, TOptions extends IAbstractTre
 		getAutomaticKeyboardNavigation,
 		disposable,
 		options: {
+			// ...options, // TODO@Joao why is this not splatted here?
 			keyboardSupport: false,
 			styleController: new DefaultStyleController(getSharedListStyleSheet()),
 			...computeStyles(themeService.getTheme(), defaultListStyles),
@@ -966,7 +967,8 @@ function workbenchTreeDataPreamble<T, TFilterData, TOptions extends IAbstractTre
 			horizontalScrolling,
 			openOnSingleClick,
 			keyboardNavigationEventFilter: createKeyboardNavigationEventFilter(container, keybindingService),
-			additionalScrollHeight
+			additionalScrollHeight,
+			hideTwistiesOfChildlessElements: options.hideTwistiesOfChildlessElements
 		} as TOptions
 	};
 }

src/vs/platform/telemetry/browser/workbenchCommonProperties.ts

@@ -9,6 +9,7 @@ export const instanceStorageKey = 'telemetry.instanceId';
 export const currentSessionDateStorageKey = 'telemetry.currentSessionDate';
 export const firstSessionDateStorageKey = 'telemetry.firstSessionDate';
 export const lastSessionDateStorageKey = 'telemetry.lastSessionDate';
+export const machineIdKey = 'telemetry.machineId';
 
 import * as Platform from 'vs/base/common/platform';
 import * as uuid from 'vs/base/common/uuid';
@@ -19,7 +20,6 @@ export async function resolveWorkbenchCommonProperties(
 	storageService: IStorageService,
 	commit: string | undefined,
 	version: string | undefined,
-	machineId: string,
 	remoteAuthority?: string,
 	resolveAdditionalProperties?: () => { [key: string]: any }
 ): Promise<{ [name: string]: string | undefined }> {
@@ -27,6 +27,12 @@ export async function resolveWorkbenchCommonProperties(
 	const firstSessionDate = storageService.get(firstSessionDateStorageKey, StorageScope.GLOBAL)!;
 	const lastSessionDate = storageService.get(lastSessionDateStorageKey, StorageScope.GLOBAL)!;
 
+	let machineId = storageService.get(machineIdKey, StorageScope.GLOBAL);
+	if (!machineId) {
+		machineId = uuid.generateUuid();
+		storageService.store(machineIdKey, machineId, StorageScope.GLOBAL);
+	}
+
 	/**
 	 * Note: In the web, session date information is fetched from browser storage, so these dates are tied to a specific
 	 * browser and not the machine overall.

src/vs/platform/telemetry/test/browser/commonProperties.test.ts

@@ -23,7 +23,7 @@ suite('Browser Telemetry - common properties', function () {
 			};
 		};
 
-		const props = await resolveWorkbenchCommonProperties(testStorageService, commit, version, 'someMachineId', undefined, resolveCommonTelemetryProperties);
+		const props = await resolveWorkbenchCommonProperties(testStorageService, commit, version, undefined, resolveCommonTelemetryProperties);
 
 		assert.ok('commitHash' in props);
 		assert.ok('sessionID' in props);
@@ -53,10 +53,10 @@ suite('Browser Telemetry - common properties', function () {
 			});
 		};
 
-		const props = await resolveWorkbenchCommonProperties(testStorageService, commit, version, 'someMachineId', undefined, resolveCommonTelemetryProperties);
+		const props = await resolveWorkbenchCommonProperties(testStorageService, commit, version, undefined, resolveCommonTelemetryProperties);
 		assert.equal(props['userId'], '1');
 
-		const props2 = await resolveWorkbenchCommonProperties(testStorageService, commit, version, 'someMachineId', undefined, resolveCommonTelemetryProperties);
+		const props2 = await resolveWorkbenchCommonProperties(testStorageService, commit, version, undefined, resolveCommonTelemetryProperties);
 		assert.equal(props2['userId'], '2');
 	});
 });

src/vs/platform/windows/common/windows.ts

@@ -219,7 +219,7 @@ export interface IAddFoldersRequest {
 }
 
 export interface IWindowConfiguration extends ParsedArgs {
-	machineId: string;
+	machineId?: string; // NOTE: This is undefined in the web, the telemetry service directly resolves this.
 	windowId: number; // TODO: should we deprecate this in favor of sessionId?
 	sessionId: string;
 	logLevel: LogLevel;

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

@@ -369,7 +369,7 @@ export abstract class BaseExtHostTerminalService implements IExtHostTerminalServ
 		if (this._terminalProcesses[id]) {
 			// Extension pty terminal only - when virtual process resize fires it means that the
 			// terminal's maximum dimensions changed
-			this._terminalProcesses[id].resize(cols, rows);
+			this._terminalProcesses[id]?.resize(cols, rows);
 		}
 	}
 
@@ -481,12 +481,12 @@ export abstract class BaseExtHostTerminalService implements IExtHostTerminalServ
 	}
 
 	public $acceptProcessInput(id: number, data: string): void {
-		this._terminalProcesses[id].input(data);
+		this._terminalProcesses[id]?.input(data);
 	}
 
 	public $acceptProcessResize(id: number, cols: number, rows: number): void {
 		try {
-			this._terminalProcesses[id].resize(cols, rows);
+			this._terminalProcesses[id]?.resize(cols, rows);
 		} catch (error) {
 			// We tried to write to a closed pipe / channel.
 			if (error.code !== 'EPIPE' && error.code !== 'ERR_IPC_CHANNEL_CLOSED') {
@@ -496,15 +496,15 @@ export abstract class BaseExtHostTerminalService implements IExtHostTerminalServ
 	}
 
 	public $acceptProcessShutdown(id: number, immediate: boolean): void {
-		this._terminalProcesses[id].shutdown(immediate);
+		this._terminalProcesses[id]?.shutdown(immediate);
 	}
 
 	public $acceptProcessRequestInitialCwd(id: number): void {
-		this._terminalProcesses[id].getInitialCwd().then(initialCwd => this._proxy.$sendProcessInitialCwd(id, initialCwd));
+		this._terminalProcesses[id]?.getInitialCwd().then(initialCwd => this._proxy.$sendProcessInitialCwd(id, initialCwd));
 	}
 
 	public $acceptProcessRequestCwd(id: number): void {
-		this._terminalProcesses[id].getCwd().then(cwd => this._proxy.$sendProcessCwd(id, cwd));
+		this._terminalProcesses[id]?.getCwd().then(cwd => this._proxy.$sendProcessCwd(id, cwd));
 	}
 
 	public $acceptProcessRequestLatency(id: number): number {

src/vs/workbench/browser/parts/editor/breadcrumbs.ts

@@ -167,132 +167,132 @@ Registry.as<IConfigurationRegistry>(Extensions.Configuration).registerConfigurat
 			type: 'boolean',
 			default: true
 		},
-		'breadcrumbs.filteredTypes.file': {
+		'breadcrumbs.showFiles': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.file', "When enabled breadcrumbs show `file`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.module': {
+		'breadcrumbs.showModules': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.module', "When enabled breadcrumbs show `module`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.namespace': {
+		'breadcrumbs.showNamespaces': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.namespace', "When enabled breadcrumbs show `namespace`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.package': {
+		'breadcrumbs.showPackages': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.package', "When enabled breadcrumbs show `package`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.class': {
+		'breadcrumbs.showClasses': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.class', "When enabled breadcrumbs show `class`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.method': {
+		'breadcrumbs.showMethods': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.method', "When enabled breadcrumbs show `method`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.property': {
+		'breadcrumbs.showProperties': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.property', "When enabled breadcrumbs show `property`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.field': {
+		'breadcrumbs.showFields': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.field', "When enabled breadcrumbs show `field`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.constructor': {
+		'breadcrumbs.showConstructors': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.constructor', "When enabled breadcrumbs show `constructor`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.enum': {
+		'breadcrumbs.showEnums': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.enum', "When enabled breadcrumbs show `enum`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.interface': {
+		'breadcrumbs.showInterfaces': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.interface', "When enabled breadcrumbs show `interface`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.function': {
+		'breadcrumbs.showFunctions': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.function', "When enabled breadcrumbs show `function`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.variable': {
+		'breadcrumbs.showVariables': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.variable', "When enabled breadcrumbs show `variable`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.constant': {
+		'breadcrumbs.showConstants': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.constant', "When enabled breadcrumbs show `constant`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.string': {
+		'breadcrumbs.showStrings': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.string', "When enabled breadcrumbs show `string`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.number': {
+		'breadcrumbs.showNumbers': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.number', "When enabled breadcrumbs show `number`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.boolean': {
+		'breadcrumbs.showBooleans': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.boolean', "When enabled breadcrumbs show `boolean`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.array': {
+		'breadcrumbs.showArrays': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.array', "When enabled breadcrumbs show `array`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.object': {
+		'breadcrumbs.showObjects': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.object', "When enabled breadcrumbs show `object`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.key': {
+		'breadcrumbs.showKeys': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.key', "When enabled breadcrumbs show `key`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.null': {
+		'breadcrumbs.showNull': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.null', "When enabled breadcrumbs show `null`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.enumMember': {
+		'breadcrumbs.showEnumMembers': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.enumMember', "When enabled breadcrumbs show `enumMember`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.struct': {
+		'breadcrumbs.showStructs': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.struct', "When enabled breadcrumbs show `struct`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.event': {
+		'breadcrumbs.showEvents': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.event', "When enabled breadcrumbs show `event`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.operator': {
+		'breadcrumbs.showOperators': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.operator', "When enabled breadcrumbs show `operator`-symbols.")
 		},
-		'breadcrumbs.filteredTypes.typeParameter': {
+		'breadcrumbs.showTypeParameters': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.typeParameter', "When enabled breadcrumbs show `typeParameter`-symbols.")

src/vs/workbench/browser/parts/editor/breadcrumbsModel.ts

@@ -14,7 +14,7 @@ import { isEqual, dirname } from 'vs/base/common/resources';
 import { URI } from 'vs/base/common/uri';
 import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
 import { IPosition } from 'vs/editor/common/core/position';
-import { DocumentSymbolProviderRegistry, SymbolKinds } from 'vs/editor/common/modes';
+import { DocumentSymbolProviderRegistry } from 'vs/editor/common/modes';
 import { OutlineElement, OutlineGroup, OutlineModel, TreeElement } from 'vs/editor/contrib/documentSymbols/outlineModel';
 import { IWorkspaceContextService, IWorkspaceFolder, WorkbenchState } from 'vs/platform/workspace/common/workspace';
 import { Schemas } from 'vs/base/common/network';
@@ -22,6 +22,7 @@ import { IConfigurationService } from 'vs/platform/configuration/common/configur
 import { BreadcrumbsConfig } from 'vs/workbench/browser/parts/editor/breadcrumbs';
 import { FileKind } from 'vs/platform/files/common/files';
 import { withNullAsUndefined } from 'vs/base/common/types';
+import { OutlineFilter } from 'vs/editor/contrib/documentSymbols/outlineTree';
 
 export class FileElement {
 	constructor(
@@ -139,7 +140,7 @@ export class EditorBreadcrumbsModel {
 
 		// update when config changes (re-render)
 		this._disposables.add(this._configurationService.onDidChangeConfiguration(e => {
-			if (e.affectsConfiguration('breadcrumbs.filteredTypes')) {
+			if (e.affectsConfiguration('breadcrumbs')) {
 				this._updateOutline(true);
 			}
 		}));
@@ -242,8 +243,11 @@ export class EditorBreadcrumbsModel {
 	}
 
 	private _isFiltered(element: TreeElement): boolean {
-		return element instanceof OutlineElement
-			&& !this._configurationService.getValue<boolean>(`breadcrumbs.filteredTypes.${SymbolKinds.toString(element.symbol.kind)}`);
+		if (element instanceof OutlineElement) {
+			const key = `breadcrumbs.${OutlineFilter.kindToConfigName[element.symbol.kind]}`;
+			return !this._configurationService.getValue<boolean>(key);
+		}
+		return false;
 	}
 
 	private _updateOutlineElements(elements: Array<OutlineModel | OutlineGroup | OutlineElement>): void {

src/vs/workbench/browser/parts/editor/breadcrumbsPicker.ts

@@ -452,7 +452,7 @@ export class BreadcrumbsOutlinePicker extends BreadcrumbsPicker {
 				sorter: new OutlineItemComparator(this._getOutlineItemCompareType()),
 				identityProvider: new OutlineIdentityProvider(),
 				keyboardNavigationLabelProvider: new OutlineNavigationLabelProvider(),
-				filter: this._instantiationService.createInstance(OutlineFilter, 'breadcrumbs.filteredTypes')
+				filter: this._instantiationService.createInstance(OutlineFilter, 'breadcrumbs')
 			}
 		);
 	}

src/vs/workbench/browser/web.main.ts

@@ -126,7 +126,7 @@ class BrowserMain extends Disposable {
 	}
 
 	private restoreBaseTheme(): void {
-		addClass(this.domElement, window.localStorage.getItem('baseTheme') || getThemeTypeSelector(DARK));
+		addClass(this.domElement, window.localStorage.getItem('vscode.baseTheme') || getThemeTypeSelector(DARK));
 	}
 
 	private saveBaseTheme(): void {
@@ -134,7 +134,7 @@ class BrowserMain extends Disposable {
 		const baseThemes = [DARK, LIGHT, HIGH_CONTRAST].map(baseTheme => getThemeTypeSelector(baseTheme));
 		for (const baseTheme of baseThemes) {
 			if (classes.indexOf(baseTheme) >= 0) {
-				window.localStorage.setItem('baseTheme', baseTheme);
+				window.localStorage.setItem('vscode.baseTheme', baseTheme);
 				break;
 			}
 		}

src/vs/workbench/browser/workbench.contribution.ts

@@ -297,7 +297,7 @@ import { isMacintosh, isWindows, isLinux, isWeb, isNative } from 'vs/base/common
 					nls.localize('window.menuBarVisibility.visible', "Menu is always visible even in full screen mode."),
 					nls.localize('window.menuBarVisibility.toggle', "Menu is hidden but can be displayed via Alt key."),
 					nls.localize('window.menuBarVisibility.hidden', "Menu is always hidden."),
-					nls.localize('window.menuBarVisibility.compact', "Menu is displayed as a compact button in the sidebar.")
+					nls.localize('window.menuBarVisibility.compact', "Menu is displayed as a compact button in the sidebar. This value is ignored when 'window.titleBarStyle' is 'native'.")
 				],
 				'default': isWeb ? 'compact' : 'default',
 				'scope': ConfigurationScope.APPLICATION,

src/vs/workbench/browser/workbench.ts

@@ -272,7 +272,7 @@ export class Workbench extends Layout {
 	private restoreFontInfo(storageService: IStorageService, configurationService: IConfigurationService): void {
 
 		// Restore (native: use storage service, web: use browser specific local storage)
-		const storedFontInfoRaw = isNative ? storageService.get('editorFontInfo', StorageScope.GLOBAL) : window.localStorage.getItem('editorFontInfo');
+		const storedFontInfoRaw = isNative ? storageService.get('editorFontInfo', StorageScope.GLOBAL) : window.localStorage.getItem('vscode.editorFontInfo');
 		if (storedFontInfoRaw) {
 			try {
 				const storedFontInfo = JSON.parse(storedFontInfoRaw);
@@ -299,7 +299,7 @@ export class Workbench extends Layout {
 			if (isNative) {
 				storageService.store('editorFontInfo', serializedFontInfoRaw, StorageScope.GLOBAL);
 			} else {
-				window.localStorage.setItem('editorFontInfo', serializedFontInfoRaw);
+				window.localStorage.setItem('vscode.editorFontInfo', serializedFontInfoRaw);
 			}
 		}
 	}

src/vs/workbench/contrib/outline/browser/outline.contribution.ts

@@ -51,132 +51,132 @@ Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration).regis
 			'type': 'boolean',
 			'default': true
 		},
-		'outline.filteredTypes.file': {
+		'outline.showFiles': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.file', "When enabled outline shows `file`-symbols.")
 		},
-		'outline.filteredTypes.module': {
+		'outline.showModules': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.module', "When enabled outline shows `module`-symbols.")
 		},
-		'outline.filteredTypes.namespace': {
+		'outline.showNamespaces': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.namespace', "When enabled outline shows `namespace`-symbols.")
 		},
-		'outline.filteredTypes.package': {
+		'outline.showPackages': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.package', "When enabled outline shows `package`-symbols.")
 		},
-		'outline.filteredTypes.class': {
+		'outline.showClasses': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.class', "When enabled outline shows `class`-symbols.")
 		},
-		'outline.filteredTypes.method': {
+		'outline.showMethods': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.method', "When enabled outline shows `method`-symbols.")
 		},
-		'outline.filteredTypes.property': {
+		'outline.showProperties': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.property', "When enabled outline shows `property`-symbols.")
 		},
-		'outline.filteredTypes.field': {
+		'outline.showFields': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.field', "When enabled outline shows `field`-symbols.")
 		},
-		'outline.filteredTypes.constructor': {
+		'outline.showConstructors': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.constructor', "When enabled outline shows `constructor`-symbols.")
 		},
-		'outline.filteredTypes.enum': {
+		'outline.showEnums': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.enum', "When enabled outline shows `enum`-symbols.")
 		},
-		'outline.filteredTypes.interface': {
+		'outline.showInterfaces': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.interface', "When enabled outline shows `interface`-symbols.")
 		},
-		'outline.filteredTypes.function': {
+		'outline.showFunctions': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.function', "When enabled outline shows `function`-symbols.")
 		},
-		'outline.filteredTypes.variable': {
+		'outline.showVariables': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.variable', "When enabled outline shows `variable`-symbols.")
 		},
-		'outline.filteredTypes.constant': {
+		'outline.showConstants': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.constant', "When enabled outline shows `constant`-symbols.")
 		},
-		'outline.filteredTypes.string': {
+		'outline.showStrings': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.string', "When enabled outline shows `string`-symbols.")
 		},
-		'outline.filteredTypes.number': {
+		'outline.showNumbers': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.number', "When enabled outline shows `number`-symbols.")
 		},
-		'outline.filteredTypes.boolean': {
+		'outline.showBooleans': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.boolean', "When enabled outline shows `boolean`-symbols.")
 		},
-		'outline.filteredTypes.array': {
+		'outline.showArrays': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.array', "When enabled outline shows `array`-symbols.")
 		},
-		'outline.filteredTypes.object': {
+		'outline.showObjects': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.object', "When enabled outline shows `object`-symbols.")
 		},
-		'outline.filteredTypes.key': {
+		'outline.showKeys': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.key', "When enabled outline shows `key`-symbols.")
 		},
-		'outline.filteredTypes.null': {
+		'outline.showNull': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.null', "When enabled outline shows `null`-symbols.")
 		},
-		'outline.filteredTypes.enumMember': {
+		'outline.showEnumMembers': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.enumMember', "When enabled outline shows `enumMember`-symbols.")
 		},
-		'outline.filteredTypes.struct': {
+		'outline.showStructs': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.struct', "When enabled outline shows `struct`-symbols.")
 		},
-		'outline.filteredTypes.event': {
+		'outline.showEvents': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.event', "When enabled outline shows `event`-symbols.")
 		},
-		'outline.filteredTypes.operator': {
+		'outline.showOperators': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.operator', "When enabled outline shows `operator`-symbols.")
 		},
-		'outline.filteredTypes.typeParameter': {
+		'outline.showTypeParameters': {
 			type: 'boolean',
 			default: true,
 			markdownDescription: localize('filteredTypes.typeParameter', "When enabled outline shows `typeParameter`-symbols.")

src/vs/workbench/contrib/outline/browser/outlinePanel.ts

@@ -314,7 +314,7 @@ export class OutlinePanel extends ViewletPanel {
 		this._treeRenderer = this._instantiationService.createInstance(OutlineElementRenderer);
 		this._treeDataSource = new OutlineDataSource();
 		this._treeComparator = new OutlineItemComparator(this._outlineViewState.sortBy);
-		this._treeFilter = this._instantiationService.createInstance(OutlineFilter, 'outline.filteredTypes');
+		this._treeFilter = this._instantiationService.createInstance(OutlineFilter, 'outline');
 		this._tree = this._instantiationService.createInstance(
 			WorkbenchDataTree,
 			'OutlinePanel',
@@ -330,7 +330,8 @@ export class OutlinePanel extends ViewletPanel {
 				sorter: this._treeComparator,
 				filter: this._treeFilter,
 				identityProvider: new OutlineIdentityProvider(),
-				keyboardNavigationLabelProvider: new OutlineNavigationLabelProvider()
+				keyboardNavigationLabelProvider: new OutlineNavigationLabelProvider(),
+				hideTwistiesOfChildlessElements: true
 			}
 		);
 
@@ -367,7 +368,7 @@ export class OutlinePanel extends ViewletPanel {
 			if (e.affectsConfiguration(OutlineConfigKeys.icons)) {
 				this._tree.updateChildren();
 			}
-			if (e.affectsConfiguration('outline.filteredTypes')) {
+			if (e.affectsConfiguration('outline')) {
 				this._treeFilter.update();
 				this._tree.refilter();
 			}

src/vs/workbench/services/environment/browser/environmentService.ts

@@ -37,10 +37,6 @@ export class BrowserWindowConfiguration implements IWindowConfiguration {
 	@memoize
 	get backupWorkspaceResource(): URI { return joinPath(this.environment.backupHome, this.options.workspaceId); }
 
-	// TODO@rachel TODO@sbatten fix me, should be stable between sessions
-	@memoize
-	get machineId(): string { return generateUuid(); }
-
 	// Currently unsupported in web
 	get filesToOpenOrCreate(): IPath[] | undefined { return undefined; }
 	get filesToDiff(): IPath[] | undefined { return undefined; }

src/vs/workbench/services/telemetry/browser/telemetryService.ts

@@ -55,7 +55,7 @@ export class TelemetryService extends Disposable implements ITelemetryService {
 		if (!!productService.enableTelemetry) {
 			const config: ITelemetryServiceConfig = {
 				appender: combinedAppender(new WebTelemetryAppender(logService, remoteAgentService), new LogAppender(logService)),
-				commonProperties: resolveWorkbenchCommonProperties(storageService, productService.commit, productService.version, environmentService.configuration.machineId, environmentService.configuration.remoteAuthority)
+				commonProperties: resolveWorkbenchCommonProperties(storageService, productService.commit, productService.version, environmentService.configuration.remoteAuthority, environmentService.options && environmentService.options.resolveCommonTelemetryProperties)
 			};
 
 			this.impl = this._register(new BaseTelemetryService(config, configurationService));

src/vs/workbench/services/telemetry/electron-browser/telemetryService.ts

@@ -38,7 +38,7 @@ export class TelemetryService extends Disposable implements ITelemetryService {
 			const channel = sharedProcessService.getChannel('telemetryAppender');
 			const config: ITelemetryServiceConfig = {
 				appender: combinedAppender(new TelemetryAppenderClient(channel), new LogAppender(logService)),
-				commonProperties: resolveWorkbenchCommonProperties(storageService, productService.commit, productService.version, environmentService.configuration.machineId, productService.msftInternalDomains, environmentService.installSourcePath, environmentService.configuration.remoteAuthority),
+				commonProperties: resolveWorkbenchCommonProperties(storageService, productService.commit, productService.version, environmentService.configuration.machineId!, productService.msftInternalDomains, environmentService.installSourcePath, environmentService.configuration.remoteAuthority),
 				piiPaths: environmentService.extensionsPath ? [environmentService.appRoot, environmentService.extensionsPath] : [environmentService.appRoot]
 			};