Merge branch 'master' into ben/ws-storage

src/vs/workbench/api/electron-browser/mainThreadComments.ts

@@ -151,7 +151,7 @@ export class MainThreadComments extends Disposable implements MainThreadComments
 	}
 
 	getVisibleEditors(): ICodeEditor[] {
-		let ret = [];
+		let ret: ICodeEditor[] = [];
 
 		this._editorService.visibleControls.forEach(control => {
 			if (isCodeEditor(control.getControl())) {

src/vs/workbench/api/electron-browser/mainThreadDebugService.ts

@@ -14,9 +14,8 @@ import {
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
 import severity from 'vs/base/common/severity';
 import { AbstractDebugAdapter } from 'vs/workbench/parts/debug/node/debugAdapter';
-import * as paths from 'vs/base/common/paths';
 import { IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
-import { convertToVSCPaths, convertToDAPaths } from 'vs/workbench/parts/debug/common/debugUtils';
+import { convertToVSCPaths, convertToDAPaths, stringToUri, uriToString } from 'vs/workbench/parts/debug/common/debugUtils';
 import { deepClone } from 'vs/base/common/objects';
 
 
@@ -215,11 +214,7 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
 
 	public $acceptDAMessage(handle: number, message: DebugProtocol.ProtocolMessage) {
 
-		convertToVSCPaths(message, source => {
-			if (typeof source.path === 'object') {
-				source.path = uri.revive(source.path).toString();
-			}
-		});
+		convertToVSCPaths(message, source => uriToString(source));
 
 		this._debugAdapters.get(handle).acceptMessage(message);
 	}
@@ -302,13 +297,7 @@ class ExtensionHostDebugAdapter extends AbstractDebugAdapter {
 		// since we modify Source.paths in the message in place, we need to make a copy of it (see #61129)
 		const msg = deepClone(message);
 
-		convertToDAPaths(msg, source => {
-			if (paths.isAbsolute(source.path)) {
-				(<any>source).path = uri.file(source.path);
-			} else {
-				(<any>source).path = uri.parse(source.path);
-			}
-		});
+		convertToDAPaths(msg, source => stringToUri(source));
 
 		this._proxy.$sendDAMessage(this._handle, msg);
 	}

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

@@ -731,6 +731,7 @@ export function createApiFactory(
 			CommentThreadCollapsibleState: extHostTypes.CommentThreadCollapsibleState,
 			CompletionItem: extHostTypes.CompletionItem,
 			CompletionItemKind: extHostTypes.CompletionItemKind,
+			CompletionItemInsertTextRule: extension.enableProposedApi ? extHostTypes.CompletionItemInsertTextRule : null,
 			CompletionList: extHostTypes.CompletionList,
 			CompletionTriggerKind: extHostTypes.CompletionTriggerKind,
 			ConfigurationTarget: extHostTypes.ConfigurationTarget,

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

@@ -377,7 +377,7 @@ export class ExtHostApiCommands {
 		};
 		return this._commands.executeCommand<modes.CompletionList>('_executeCompletionItemProvider', args).then(result => {
 			if (result) {
-				const items = result.suggestions.map(suggestion => typeConverters.Suggest.to(suggestion));
+				const items = result.suggestions.map(suggestion => typeConverters.CompletionItem.to(suggestion));
 				return new types.CompletionList(items, result.incomplete);
 			}
 			return undefined;

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

@@ -27,7 +27,7 @@ import { getTerminalLauncher, hasChildprocesses, prepareCommand } from 'vs/workb
 import { IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
 import { AbstractVariableResolverService } from 'vs/workbench/services/configurationResolver/node/variableResolver';
 import { ExtHostConfiguration } from './extHostConfiguration';
-import { convertToVSCPaths, convertToDAPaths } from 'vs/workbench/parts/debug/common/debugUtils';
+import { convertToVSCPaths, convertToDAPaths, stringToUri, uriToString } from 'vs/workbench/parts/debug/common/debugUtils';
 import { ExtHostTerminalService } from 'vs/workbench/api/node/extHostTerminalService';
 import { IDisposable } from 'vs/base/common/lifecycle';
 import { IConfigurationResolverService } from 'vs/workbench/services/configurationResolver/common/configurationResolver';
@@ -400,11 +400,7 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {
 						}
 
 						// DA -> VS Code
-						convertToVSCPaths(msg, source => {
-							if (paths.isAbsolute(source.path)) {
-								(<any>source).path = URI.file(source.path);
-							}
-						});
+						convertToVSCPaths(msg, source => stringToUri(source));
 
 						mythis._debugServiceProxy.$acceptDAMessage(handle, msg);
 					});
@@ -435,11 +431,7 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {
 
 	public $sendDAMessage(handle: number, message: DebugProtocol.ProtocolMessage): TPromise<void> {
 		// VS Code -> DA
-		convertToDAPaths(message, source => {
-			if (typeof source.path === 'object') {
-				source.path = URI.revive(source.path).fsPath;
-			}
-		});
+		convertToDAPaths(message, source => uriToString(source));
 
 		const tracker = this._debugAdaptersTrackers.get(handle);
 		if (tracker) {

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

@@ -153,41 +153,59 @@ export class ExtHostFileSystem implements ExtHostFileSystemShape {
 		return { type, ctime, mtime, size };
 	}
 
+	private _checkProviderExists(handle: number): void {
+		if (!this._fsProvider.has(handle)) {
+			const err = new Error();
+			err.name = 'ENOPRO';
+			err.message = `no provider`;
+			throw err;
+		}
+	}
+
 	$stat(handle: number, resource: UriComponents): Promise<files.IStat> {
+		this._checkProviderExists(handle);
 		return Promise.resolve(this._fsProvider.get(handle).stat(URI.revive(resource))).then(ExtHostFileSystem._asIStat);
 	}
 
 	$readdir(handle: number, resource: UriComponents): Promise<[string, files.FileType][]> {
+		this._checkProviderExists(handle);
 		return Promise.resolve(this._fsProvider.get(handle).readDirectory(URI.revive(resource)));
 	}
 
 	$readFile(handle: number, resource: UriComponents): Promise<Buffer> {
+		this._checkProviderExists(handle);
 		return Promise.resolve(this._fsProvider.get(handle).readFile(URI.revive(resource))).then(data => {
 			return Buffer.isBuffer(data) ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
 		});
 	}
 
 	$writeFile(handle: number, resource: UriComponents, content: Buffer, opts: files.FileWriteOptions): Promise<void> {
+		this._checkProviderExists(handle);
 		return Promise.resolve(this._fsProvider.get(handle).writeFile(URI.revive(resource), content, opts));
 	}
 
 	$delete(handle: number, resource: UriComponents, opts: files.FileDeleteOptions): Promise<void> {
+		this._checkProviderExists(handle);
 		return Promise.resolve(this._fsProvider.get(handle).delete(URI.revive(resource), opts));
 	}
 
 	$rename(handle: number, oldUri: UriComponents, newUri: UriComponents, opts: files.FileOverwriteOptions): Promise<void> {
+		this._checkProviderExists(handle);
 		return Promise.resolve(this._fsProvider.get(handle).rename(URI.revive(oldUri), URI.revive(newUri), opts));
 	}
 
 	$copy(handle: number, oldUri: UriComponents, newUri: UriComponents, opts: files.FileOverwriteOptions): Promise<void> {
+		this._checkProviderExists(handle);
 		return Promise.resolve(this._fsProvider.get(handle).copy(URI.revive(oldUri), URI.revive(newUri), opts));
 	}
 
 	$mkdir(handle: number, resource: UriComponents): Promise<void> {
+		this._checkProviderExists(handle);
 		return Promise.resolve(this._fsProvider.get(handle).createDirectory(URI.revive(resource)));
 	}
 
 	$watch(handle: number, session: number, resource: UriComponents, opts: files.IWatchOptions): void {
+		this._checkProviderExists(handle);
 		let subscription = this._fsProvider.get(handle).watch(URI.revive(resource), opts);
 		this._watches.set(session, subscription);
 	}
@@ -201,18 +219,22 @@ export class ExtHostFileSystem implements ExtHostFileSystemShape {
 	}
 
 	$open(handle: number, resource: UriComponents): Promise<number> {
+		this._checkProviderExists(handle);
 		return Promise.resolve(this._fsProvider.get(handle).open(URI.revive(resource)));
 	}
 
 	$close(handle: number, fd: number): Promise<void> {
+		this._checkProviderExists(handle);
 		return Promise.resolve(this._fsProvider.get(handle).close(fd));
 	}
 
 	$read(handle: number, fd: number, pos: number, data: Buffer, offset: number, length: number): Promise<number> {
+		this._checkProviderExists(handle);
 		return Promise.resolve(this._fsProvider.get(handle).read(fd, pos, data, offset, length));
 	}
 
 	$write(handle: number, fd: number, pos: number, data: Buffer, offset: number, length: number): Promise<number> {
+		this._checkProviderExists(handle);
 		return Promise.resolve(this._fsProvider.get(handle).write(fd, pos, data, offset, length));
 	}
 

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

@@ -575,7 +575,7 @@ class SuggestAdapter {
 		const pos = typeConvert.Position.to(position);
 
 		return asThenable<vscode.CompletionItem[] | vscode.CompletionList>(
-			() => this._provider.provideCompletionItems(doc, pos, token, typeConvert.CompletionContext.from(context))
+			() => this._provider.provideCompletionItems(doc, pos, token, typeConvert.CompletionContext.to(context))
 		).then(value => {
 
 			const _id = this._idPool++;
@@ -671,6 +671,7 @@ class SuggestAdapter {
 			//
 			range: undefined,
 			insertText: undefined,
+			insertTextRules: typeConvert.CompletionItemInsertTextRule.from(item.insertTextRules),
 			additionalTextEdits: item.additionalTextEdits && item.additionalTextEdits.map(typeConvert.TextEdit.from),
 			command: this._commands.toInternal(item.command),
 			commitCharacters: item.commitCharacters,
@@ -683,19 +684,16 @@ class SuggestAdapter {
 		// 'insertText'-logic
 		if (item.textEdit) {
 			result.insertText = item.textEdit.newText;
-			result.insertTextIsSnippet = false;
 
 		} else if (typeof item.insertText === 'string') {
 			result.insertText = item.insertText;
-			result.insertTextIsSnippet = false;
 
 		} else if (item.insertText instanceof SnippetString) {
 			result.insertText = item.insertText.value;
-			result.insertTextIsSnippet = true;
+			result.insertTextRules += modes.CompletionItemInsertTextRule.InsertAsSnippet;
 
 		} else {
 			result.insertText = item.label;
-			result.insertTextIsSnippet = false;
 		}
 
 		// 'overwrite[Before|After]'-logic

src/vs/workbench/api/node/extHostSearch.fileIndex.ts

@@ -7,7 +7,6 @@ import * as path from 'path';
 import * as arrays from 'vs/base/common/arrays';
 import { CancelablePromise, createCancelablePromise } from 'vs/base/common/async';
 import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';
-import { toErrorMessage } from 'vs/base/common/errorMessage';
 import { canceled } from 'vs/base/common/errors';
 import * as glob from 'vs/base/common/glob';
 import * as resources from 'vs/base/common/resources';
@@ -17,9 +16,9 @@ import { URI } from 'vs/base/common/uri';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { compareItemsByScore, IItemAccessor, prepareQuery, ScorerCache } from 'vs/base/parts/quickopen/common/quickOpenScorer';
 import { ICachedSearchStats, IFileIndexProviderStats, IFileMatch, IFileSearchStats, IFolderQuery, IRawSearchQuery, ISearchCompleteStats, ISearchQuery } from 'vs/platform/search/common/search';
+import { IDirectoryEntry, IDirectoryTree, IInternalFileMatch } from 'vs/workbench/services/search/node/fileSearchManager';
+import { QueryGlobTester, resolvePatternsForProvider } from 'vs/workbench/services/search/node/search';
 import * as vscode from 'vscode';
-import { resolvePatternsForProvider, QueryGlobTester } from 'vs/workbench/services/search/node/search';
-import { IInternalFileMatch, IDirectoryTree, IDirectoryEntry } from 'vs/workbench/services/search/node/fileSearchManager';
 
 interface IInternalSearchComplete<T = IFileSearchStats> {
 	limitHit: boolean;
@@ -67,10 +66,6 @@ export class FileIndexSearchEngine {
 	}
 
 	public search(_onResult: (match: IInternalFileMatch) => void): TPromise<{ isLimitHit: boolean, stats: IFileIndexProviderStats }> {
-		if (this.config.folderQueries.length !== 1) {
-			throw new Error('Searches just one folder');
-		}
-
 		// Searches a single folder
 		const folderQuery = this.config.folderQueries[0];
 
@@ -99,15 +94,25 @@ export class FileIndexSearchEngine {
 					});
 			}
 
-			return this.searchInFolder(folderQuery, _onResult)
-				.then(stats => {
-					resolve({
-						isLimitHit: this.isLimitHit,
-						stats
-					});
-				}, (err: Error) => {
-					reject(new Error(toErrorMessage(err)));
+			return Promise.all(this.config.folderQueries.map(fq => this.searchInFolder(folderQuery, onResult))).then(stats => {
+				resolve({
+					isLimitHit: this.isLimitHit,
+					stats: {
+						directoriesWalked: this.dirsWalked,
+						filesWalked: this.filesWalked,
+						fileWalkTime: stats.map(s => s.fileWalkTime).reduce((s, c) => s + c, 0),
+						providerTime: stats.map(s => s.providerTime).reduce((s, c) => s + c, 0),
+						providerResultCount: stats.map(s => s.providerResultCount).reduce((s, c) => s + c, 0)
+					}
 				});
+			}, (errs: Error[]) => {
+				if (!Array.isArray(errs)) {
+					errs = [errs];
+				}
+
+				errs = errs.filter(e => !!e);
+				return TPromise.wrapError(errs[0]);
+			});
 		});
 	}
 

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

@@ -42,14 +42,14 @@ export interface SelectionLike extends RangeLike {
 export namespace Selection {
 
 	export function to(selection: ISelection): types.Selection {
-		let { selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn } = selection;
-		let start = new types.Position(selectionStartLineNumber - 1, selectionStartColumn - 1);
-		let end = new types.Position(positionLineNumber - 1, positionColumn - 1);
+		const { selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn } = selection;
+		const start = new types.Position(selectionStartLineNumber - 1, selectionStartColumn - 1);
+		const end = new types.Position(positionLineNumber - 1, positionColumn - 1);
 		return new types.Selection(start, end);
 	}
 
 	export function from(selection: SelectionLike): ISelection {
-		let { anchor, active } = selection;
+		const { anchor, active } = selection;
 		return {
 			selectionStartLineNumber: anchor.line + 1,
 			selectionStartColumn: anchor.character + 1,
@@ -64,7 +64,7 @@ export namespace Range {
 		if (!range) {
 			return undefined;
 		}
-		let { start, end } = range;
+		const { start, end } = range;
 		return {
 			startLineNumber: start.line + 1,
 			startColumn: start.character + 1,
@@ -77,7 +77,7 @@ export namespace Range {
 		if (!range) {
 			return undefined;
 		}
-		let { startLineNumber, startColumn, endLineNumber, endColumn } = range;
+		const { startLineNumber, startColumn, endLineNumber, endColumn } = range;
 		return new types.Range(startLineNumber - 1, startColumn - 1, endLineNumber - 1, endColumn - 1);
 	}
 }
@@ -252,21 +252,22 @@ export function fromRangeOrRangeWithMessage(ranges: vscode.Range[] | vscode.Deco
 	}
 }
 
-export const TextEdit = {
+export namespace TextEdit {
 
-	from(edit: vscode.TextEdit): modes.TextEdit {
+	export function from(edit: vscode.TextEdit): modes.TextEdit {
 		return <modes.TextEdit>{
 			text: edit.newText,
 			eol: EndOfLine.from(edit.newEol),
 			range: Range.from(edit.range)
 		};
-	},
-	to(edit: modes.TextEdit): types.TextEdit {
-		let result = new types.TextEdit(Range.to(edit.range), edit.text);
+	}
+
+	export function to(edit: modes.TextEdit): types.TextEdit {
+		const result = new types.TextEdit(Range.to(edit.range), edit.text);
 		result.newEol = EndOfLine.to(edit.eol);
 		return result;
 	}
-};
+}
 
 export namespace WorkspaceEdit {
 	export function from(value: vscode.WorkspaceEdit, documents?: ExtHostDocumentsAndEditors): WorkspaceEditDto {
@@ -277,7 +278,7 @@ export namespace WorkspaceEdit {
 			const [uri, uriOrEdits] = entry;
 			if (Array.isArray(uriOrEdits)) {
 				// text edits
-				let doc = documents ? documents.getDocument(uri.toString()) : undefined;
+				const doc = documents ? documents.getDocument(uri.toString()) : undefined;
 				result.edits.push(<ResourceTextEditDto>{ resource: uri, modelVersionId: doc && doc.version, edits: uriOrEdits.map(TextEdit.from) });
 			} else {
 				// resource edits
@@ -343,7 +344,7 @@ export namespace SymbolKind {
 	}
 
 	export function to(kind: modes.SymbolKind): vscode.SymbolKind {
-		for (let k in _fromMapping) {
+		for (const k in _fromMapping) {
 			if (_fromMapping[k] === kind) {
 				return Number(k);
 			}
@@ -373,7 +374,7 @@ export namespace WorkspaceSymbol {
 
 export namespace DocumentSymbol {
 	export function from(info: vscode.DocumentSymbol): modes.DocumentSymbol {
-		let result: modes.DocumentSymbol = {
+		const result: modes.DocumentSymbol = {
 			name: info.name,
 			detail: info.detail,
 			range: Range.from(info.range),
@@ -386,7 +387,7 @@ export namespace DocumentSymbol {
 		return result;
 	}
 	export function to(info: modes.DocumentSymbol): vscode.DocumentSymbol {
-		let result = new types.DocumentSymbol(
+		const result = new types.DocumentSymbol(
 			info.name,
 			info.detail,
 			SymbolKind.to(info.kind),
@@ -400,17 +401,18 @@ export namespace DocumentSymbol {
 	}
 }
 
-export const location = {
-	from(value: vscode.Location): modes.Location {
+export namespace location {
+	export function from(value: vscode.Location): modes.Location {
 		return {
 			range: value.range && Range.from(value.range),
 			uri: value.uri
 		};
-	},
-	to(value: modes.Location): types.Location {
+	}
+
+	export function to(value: modes.Location): types.Location {
 		return new types.Location(value.uri, Range.to(value.range));
 	}
-};
+}
 
 export namespace DefinitionLink {
 	export function from(value: vscode.Location | vscode.DefinitionLink): modes.DefinitionLink {
@@ -454,7 +456,7 @@ export namespace DocumentHighlight {
 }
 
 export namespace CompletionTriggerKind {
-	export function from(kind: modes.CompletionTriggerKind) {
+	export function to(kind: modes.CompletionTriggerKind) {
 		switch (kind) {
 			case modes.CompletionTriggerKind.TriggerCharacter:
 				return types.CompletionTriggerKind.TriggerCharacter;
@@ -468,17 +470,17 @@ export namespace CompletionTriggerKind {
 }
 
 export namespace CompletionContext {
-	export function from(context: modes.CompletionContext): types.CompletionContext {
+	export function to(context: modes.CompletionContext): types.CompletionContext {
 		return {
-			triggerKind: CompletionTriggerKind.from(context.triggerKind),
+			triggerKind: CompletionTriggerKind.to(context.triggerKind),
 			triggerCharacter: context.triggerCharacter
 		};
 	}
 }
 
-export const CompletionItemKind = {
+export namespace CompletionItemKind {
 
-	from(kind: types.CompletionItemKind): modes.CompletionItemKind {
+	export function from(kind: types.CompletionItemKind): modes.CompletionItemKind {
 		switch (kind) {
 			case types.CompletionItemKind.Method: return modes.CompletionItemKind.Method;
 			case types.CompletionItemKind.Function: return modes.CompletionItemKind.Function;
@@ -507,9 +509,9 @@ export const CompletionItemKind = {
 			case types.CompletionItemKind.TypeParameter: return modes.CompletionItemKind.TypeParameter;
 		}
 		return modes.CompletionItemKind.Property;
-	},
+	}
 
-	to(kind: modes.CompletionItemKind): types.CompletionItemKind {
+	export function to(kind: modes.CompletionItemKind): types.CompletionItemKind {
 		switch (kind) {
 			case modes.CompletionItemKind.Method: return types.CompletionItemKind.Method;
 			case modes.CompletionItemKind.Function: return types.CompletionItemKind.Function;
@@ -539,9 +541,28 @@ export const CompletionItemKind = {
 		}
 		return types.CompletionItemKind.Property;
 	}
-};
+}
 
-export namespace Suggest {
+export namespace CompletionItemInsertTextRule {
+
+	export function from(rule: types.CompletionItemInsertTextRule): modes.CompletionItemInsertTextRule {
+		let result = 0;
+		if ((rule & types.CompletionItemInsertTextRule.KeepWhitespace)) {
+			result += modes.CompletionItemInsertTextRule.KeepWhitespace;
+		}
+		return result;
+	}
+
+	export function to(rule: modes.CompletionItemInsertTextRule): types.CompletionItemInsertTextRule {
+		let result = 0;
+		if ((rule & modes.CompletionItemInsertTextRule.KeepWhitespace)) {
+			result += types.CompletionItemInsertTextRule.KeepWhitespace;
+		}
+		return result;
+	}
+}
+
+export namespace CompletionItem {
 
 	export function to(suggestion: modes.CompletionItem): types.CompletionItem {
 		const result = new types.CompletionItem(suggestion.label);
@@ -554,15 +575,14 @@ export namespace Suggest {
 		result.preselect = suggestion.preselect;
 		result.commitCharacters = suggestion.commitCharacters;
 		result.range = Range.to(suggestion.range);
-
+		result.insertTextRules = CompletionItemInsertTextRule.to(suggestion.insertTextRules);
 		// 'inserText'-logic
-		if (suggestion.insertTextIsSnippet) {
+		if (suggestion.insertTextRules & modes.CompletionItemInsertTextRule.InsertAsSnippet) {
 			result.insertText = new types.SnippetString(suggestion.insertText);
 		} else {
 			result.insertText = suggestion.insertText;
 			result.textEdit = new types.TextEdit(result.range, result.insertText);
 		}
-
 		// TODO additionalEdits, command
 
 		return result;
@@ -638,7 +658,7 @@ export namespace DocumentLink {
 
 export namespace ColorPresentation {
 	export function to(colorPresentation: modes.IColorPresentation): types.ColorPresentation {
-		let cp = new types.ColorPresentation(colorPresentation.label);
+		const cp = new types.ColorPresentation(colorPresentation.label);
 		if (colorPresentation.textEdit) {
 			cp.textEdit = TextEdit.to(colorPresentation.textEdit);
 		}
@@ -716,7 +736,7 @@ export namespace ProgressLocation {
 
 export namespace FoldingRange {
 	export function from(r: vscode.FoldingRange): modes.FoldingRange {
-		let range: modes.FoldingRange = { start: r.start + 1, end: r.end + 1 };
+		const range: modes.FoldingRange = { start: r.start + 1, end: r.end + 1 };
 		if (r.kind) {
 			range.kind = FoldingRangeKind.from(r.kind);
 		}

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

@@ -1157,6 +1157,10 @@ export enum CompletionItemKind {
 	TypeParameter = 24
 }
 
+export enum CompletionItemInsertTextRule {
+	KeepWhitespace = 0b1
+}
+
 export class CompletionItem implements vscode.CompletionItem {
 
 	label: string;
@@ -1167,6 +1171,7 @@ export class CompletionItem implements vscode.CompletionItem {
 	filterText: string;
 	preselect: boolean;
 	insertText: string | SnippetString;
+	insertTextRules: CompletionItemInsertTextRule;
 	range: Range;
 	commitCharacters: string[];
 	textEdit: TextEdit;