Merge commit 'be3e8236086165e5e45a5a10783823874b3f3ebd' as 'lib/vscode'

lib/vscode/extensions/html-language-features/client/src/browser/htmlClientMain.ts

@@ -0,0 +1,32 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ExtensionContext, Uri } from 'vscode';
+import { LanguageClientOptions } from 'vscode-languageclient';
+import { startClient, LanguageClientConstructor } from '../htmlClient';
+import { LanguageClient } from 'vscode-languageclient/browser';
+
+declare const Worker: {
+	new(stringUrl: string): any;
+};
+declare const TextDecoder: {
+	new(encoding?: string): { decode(buffer: ArrayBuffer): string; };
+};
+
+// this method is called when vs code is activated
+export function activate(context: ExtensionContext) {
+	const serverMain = Uri.joinPath(context.extensionUri, 'server/dist/browser/htmlServerMain.js');
+	try {
+		const worker = new Worker(serverMain.toString());
+		const newLanguageClient: LanguageClientConstructor = (id: string, name: string, clientOptions: LanguageClientOptions) => {
+			return new LanguageClient(id, name, clientOptions, worker);
+		};
+
+		startClient(context, newLanguageClient, { TextDecoder });
+
+	} catch (e) {
+		console.log(e);
+	}
+}

lib/vscode/extensions/html-language-features/client/src/customData.ts

@@ -0,0 +1,88 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { workspace, extensions, Uri, EventEmitter, Disposable } from 'vscode';
+import { resolvePath, joinPath } from './requests';
+
+export function getCustomDataSource(toDispose: Disposable[]) {
+	let pathsInWorkspace = getCustomDataPathsInAllWorkspaces();
+	let pathsInExtensions = getCustomDataPathsFromAllExtensions();
+
+	const onChange = new EventEmitter<void>();
+
+	toDispose.push(extensions.onDidChange(_ => {
+		const newPathsInExtensions = getCustomDataPathsFromAllExtensions();
+		if (newPathsInExtensions.length !== pathsInExtensions.length || !newPathsInExtensions.every((val, idx) => val === pathsInExtensions[idx])) {
+			pathsInExtensions = newPathsInExtensions;
+			onChange.fire();
+		}
+	}));
+	toDispose.push(workspace.onDidChangeConfiguration(e => {
+		if (e.affectsConfiguration('html.customData')) {
+			pathsInWorkspace = getCustomDataPathsInAllWorkspaces();
+			onChange.fire();
+		}
+	}));
+
+	return {
+		get uris() {
+			return pathsInWorkspace.concat(pathsInExtensions);
+		},
+		get onDidChange() {
+			return onChange.event;
+		}
+	};
+}
+
+
+function getCustomDataPathsInAllWorkspaces(): string[] {
+	const workspaceFolders = workspace.workspaceFolders;
+
+	const dataPaths: string[] = [];
+
+	if (!workspaceFolders) {
+		return dataPaths;
+	}
+
+	const collect = (paths: string[] | undefined, rootFolder: Uri) => {
+		if (Array.isArray(paths)) {
+			for (const path of paths) {
+				if (typeof path === 'string') {
+					dataPaths.push(resolvePath(rootFolder, path).toString());
+				}
+			}
+		}
+	};
+
+	for (let i = 0; i < workspaceFolders.length; i++) {
+		const folderUri = workspaceFolders[i].uri;
+		const allHtmlConfig = workspace.getConfiguration('html', folderUri);
+		const customDataInspect = allHtmlConfig.inspect<string[]>('customData');
+		if (customDataInspect) {
+			collect(customDataInspect.workspaceFolderValue, folderUri);
+			if (i === 0) {
+				if (workspace.workspaceFile) {
+					collect(customDataInspect.workspaceValue, workspace.workspaceFile);
+				}
+				collect(customDataInspect.globalValue, folderUri);
+			}
+		}
+
+	}
+	return dataPaths;
+}
+
+function getCustomDataPathsFromAllExtensions(): string[] {
+	const dataPaths: string[] = [];
+	for (const extension of extensions.all) {
+		const customData = extension.packageJSON?.contributes?.html?.customData;
+		if (Array.isArray(customData)) {
+			for (const rp of customData) {
+				dataPaths.push(joinPath(extension.extensionUri, rp).toString());
+			}
+		}
+	}
+	return dataPaths;
+}

lib/vscode/extensions/html-language-features/client/src/htmlClient.ts

@@ -0,0 +1,322 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as nls from 'vscode-nls';
+const localize = nls.loadMessageBundle();
+
+import {
+	languages, ExtensionContext, IndentAction, Position, TextDocument, Range, CompletionItem, CompletionItemKind, SnippetString, workspace, extensions,
+	Disposable, FormattingOptions, CancellationToken, ProviderResult, TextEdit, CompletionContext, CompletionList, SemanticTokensLegend,
+	DocumentSemanticTokensProvider, DocumentRangeSemanticTokensProvider, SemanticTokens, window, commands
+} from 'vscode';
+import {
+	LanguageClientOptions, RequestType, TextDocumentPositionParams, DocumentRangeFormattingParams,
+	DocumentRangeFormattingRequest, ProvideCompletionItemsSignature, TextDocumentIdentifier, RequestType0, Range as LspRange, NotificationType, CommonLanguageClient
+} from 'vscode-languageclient';
+import { EMPTY_ELEMENTS } from './htmlEmptyTagsShared';
+import { activateTagClosing } from './tagClosing';
+import { RequestService } from './requests';
+import { getCustomDataSource } from './customData';
+
+namespace CustomDataChangedNotification {
+	export const type: NotificationType<string[]> = new NotificationType('html/customDataChanged');
+}
+
+namespace TagCloseRequest {
+	export const type: RequestType<TextDocumentPositionParams, string, any, any> = new RequestType('html/tag');
+}
+namespace OnTypeRenameRequest {
+	export const type: RequestType<TextDocumentPositionParams, LspRange[] | null, any, any> = new RequestType('html/onTypeRename');
+}
+
+// experimental: semantic tokens
+interface SemanticTokenParams {
+	textDocument: TextDocumentIdentifier;
+	ranges?: LspRange[];
+}
+namespace SemanticTokenRequest {
+	export const type: RequestType<SemanticTokenParams, number[] | null, any, any> = new RequestType('html/semanticTokens');
+}
+namespace SemanticTokenLegendRequest {
+	export const type: RequestType0<{ types: string[]; modifiers: string[] } | null, any, any> = new RequestType0('html/semanticTokenLegend');
+}
+
+namespace SettingIds {
+	export const renameOnType = 'editor.renameOnType';
+	export const formatEnable = 'html.format.enable';
+
+}
+
+export interface TelemetryReporter {
+	sendTelemetryEvent(eventName: string, properties?: {
+		[key: string]: string;
+	}, measurements?: {
+		[key: string]: number;
+	}): void;
+}
+
+export type LanguageClientConstructor = (name: string, description: string, clientOptions: LanguageClientOptions) => CommonLanguageClient;
+
+export interface Runtime {
+	TextDecoder: { new(encoding?: string): { decode(buffer: ArrayBuffer): string; } };
+	fs?: RequestService;
+	telemetry?: TelemetryReporter;
+}
+
+export function startClient(context: ExtensionContext, newLanguageClient: LanguageClientConstructor, runtime: Runtime) {
+
+	let toDispose = context.subscriptions;
+
+
+	let documentSelector = ['html', 'handlebars'];
+	let embeddedLanguages = { css: true, javascript: true };
+
+	let rangeFormatting: Disposable | undefined = undefined;
+
+	const customDataSource = getCustomDataSource(context.subscriptions);
+
+	// Options to control the language client
+	let clientOptions: LanguageClientOptions = {
+		documentSelector,
+		synchronize: {
+			configurationSection: ['html', 'css', 'javascript'], // the settings to synchronize
+		},
+		initializationOptions: {
+			embeddedLanguages,
+			handledSchemas: ['file'],
+			provideFormatter: false, // tell the server to not provide formatting capability and ignore the `html.format.enable` setting.
+		},
+		middleware: {
+			// testing the replace / insert mode
+			provideCompletionItem(document: TextDocument, position: Position, context: CompletionContext, token: CancellationToken, next: ProvideCompletionItemsSignature): ProviderResult<CompletionItem[] | CompletionList> {
+				function updateRanges(item: CompletionItem) {
+					const range = item.range;
+					if (range instanceof Range && range.end.isAfter(position) && range.start.isBeforeOrEqual(position)) {
+						item.range = { inserting: new Range(range.start, position), replacing: range };
+					}
+				}
+				function updateProposals(r: CompletionItem[] | CompletionList | null | undefined): CompletionItem[] | CompletionList | null | undefined {
+					if (r) {
+						(Array.isArray(r) ? r : r.items).forEach(updateRanges);
+					}
+					return r;
+				}
+				const isThenable = <T>(obj: ProviderResult<T>): obj is Thenable<T> => obj && (<any>obj)['then'];
+
+				const r = next(document, position, context, token);
+				if (isThenable<CompletionItem[] | CompletionList | null | undefined>(r)) {
+					return r.then(updateProposals);
+				}
+				return updateProposals(r);
+			}
+		}
+	};
+
+	// Create the language client and start the client.
+	let client = newLanguageClient('html', localize('htmlserver.name', 'HTML Language Server'), clientOptions);
+	client.registerProposedFeatures();
+
+	let disposable = client.start();
+	toDispose.push(disposable);
+	client.onReady().then(() => {
+
+		client.sendNotification(CustomDataChangedNotification.type, customDataSource.uris);
+		customDataSource.onDidChange(() => {
+			client.sendNotification(CustomDataChangedNotification.type, customDataSource.uris);
+		});
+
+		let tagRequestor = (document: TextDocument, position: Position) => {
+			let param = client.code2ProtocolConverter.asTextDocumentPositionParams(document, position);
+			return client.sendRequest(TagCloseRequest.type, param);
+		};
+		disposable = activateTagClosing(tagRequestor, { html: true, handlebars: true }, 'html.autoClosingTags');
+		toDispose.push(disposable);
+
+		disposable = client.onTelemetry(e => {
+			runtime.telemetry?.sendTelemetryEvent(e.key, e.data);
+		});
+		toDispose.push(disposable);
+
+		// manually register / deregister format provider based on the `html.format.enable` setting avoiding issues with late registration. See #71652.
+		updateFormatterRegistration();
+		toDispose.push({ dispose: () => rangeFormatting && rangeFormatting.dispose() });
+		toDispose.push(workspace.onDidChangeConfiguration(e => e.affectsConfiguration(SettingIds.formatEnable) && updateFormatterRegistration()));
+
+		client.sendRequest(SemanticTokenLegendRequest.type).then(legend => {
+			if (legend) {
+				const provider: DocumentSemanticTokensProvider & DocumentRangeSemanticTokensProvider = {
+					provideDocumentSemanticTokens(doc) {
+						const params: SemanticTokenParams = {
+							textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(doc),
+						};
+						return client.sendRequest(SemanticTokenRequest.type, params).then(data => {
+							return data && new SemanticTokens(new Uint32Array(data));
+						});
+					},
+					provideDocumentRangeSemanticTokens(doc, range) {
+						const params: SemanticTokenParams = {
+							textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(doc),
+							ranges: [client.code2ProtocolConverter.asRange(range)]
+						};
+						return client.sendRequest(SemanticTokenRequest.type, params).then(data => {
+							return data && new SemanticTokens(new Uint32Array(data));
+						});
+					}
+				};
+				toDispose.push(languages.registerDocumentSemanticTokensProvider(documentSelector, provider, new SemanticTokensLegend(legend.types, legend.modifiers)));
+			}
+		});
+
+		disposable = languages.registerOnTypeRenameProvider(documentSelector, {
+			async provideOnTypeRenameRanges(document, position) {
+				const param = client.code2ProtocolConverter.asTextDocumentPositionParams(document, position);
+				return client.sendRequest(OnTypeRenameRequest.type, param).then(response => {
+					if (response) {
+						return {
+							ranges: response.map(r => client.protocol2CodeConverter.asRange(r))
+						};
+					}
+					return undefined;
+				});
+			}
+		});
+		toDispose.push(disposable);
+
+	});
+
+	function updateFormatterRegistration() {
+		const formatEnabled = workspace.getConfiguration().get(SettingIds.formatEnable);
+		if (!formatEnabled && rangeFormatting) {
+			rangeFormatting.dispose();
+			rangeFormatting = undefined;
+		} else if (formatEnabled && !rangeFormatting) {
+			rangeFormatting = languages.registerDocumentRangeFormattingEditProvider(documentSelector, {
+				provideDocumentRangeFormattingEdits(document: TextDocument, range: Range, options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]> {
+					let params: DocumentRangeFormattingParams = {
+						textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
+						range: client.code2ProtocolConverter.asRange(range),
+						options: client.code2ProtocolConverter.asFormattingOptions(options)
+					};
+					return client.sendRequest(DocumentRangeFormattingRequest.type, params, token).then(
+						client.protocol2CodeConverter.asTextEdits,
+						(error) => {
+							client.handleFailedRequest(DocumentRangeFormattingRequest.type, error, []);
+							return Promise.resolve([]);
+						}
+					);
+				}
+			});
+		}
+	}
+
+	languages.setLanguageConfiguration('html', {
+		indentationRules: {
+			increaseIndentPattern: /<(?!\?|(?:area|base|br|col|frame|hr|html|img|input|link|meta|param)\b|[^>]*\/>)([-_\.A-Za-z0-9]+)(?=\s|>)\b[^>]*>(?!.*<\/\1>)|<!--(?!.*-->)|\{[^}"']*$/,
+			decreaseIndentPattern: /^\s*(<\/(?!html)[-_\.A-Za-z0-9]+\b[^>]*>|-->|\})/
+		},
+		wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,
+		onEnterRules: [
+			{
+				beforeText: new RegExp(`<(?!(?:${EMPTY_ELEMENTS.join('|')}))([_:\\w][_:\\w-.\\d]*)([^/>]*(?!/)>)[^<]*$`, 'i'),
+				afterText: /^<\/([_:\w][_:\w-.\d]*)\s*>/i,
+				action: { indentAction: IndentAction.IndentOutdent }
+			},
+			{
+				beforeText: new RegExp(`<(?!(?:${EMPTY_ELEMENTS.join('|')}))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$`, 'i'),
+				action: { indentAction: IndentAction.Indent }
+			}
+		],
+	});
+
+	languages.setLanguageConfiguration('handlebars', {
+		wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,
+		onEnterRules: [
+			{
+				beforeText: new RegExp(`<(?!(?:${EMPTY_ELEMENTS.join('|')}))([_:\\w][_:\\w-.\\d]*)([^/>]*(?!/)>)[^<]*$`, 'i'),
+				afterText: /^<\/([_:\w][_:\w-.\d]*)\s*>/i,
+				action: { indentAction: IndentAction.IndentOutdent }
+			},
+			{
+				beforeText: new RegExp(`<(?!(?:${EMPTY_ELEMENTS.join('|')}))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$`, 'i'),
+				action: { indentAction: IndentAction.Indent }
+			}
+		],
+	});
+
+	const regionCompletionRegExpr = /^(\s*)(<(!(-(-\s*(#\w*)?)?)?)?)?$/;
+	const htmlSnippetCompletionRegExpr = /^(\s*)(<(h(t(m(l)?)?)?)?)?$/;
+	languages.registerCompletionItemProvider(documentSelector, {
+		provideCompletionItems(doc, pos) {
+			const results: CompletionItem[] = [];
+			let lineUntilPos = doc.getText(new Range(new Position(pos.line, 0), pos));
+			let match = lineUntilPos.match(regionCompletionRegExpr);
+			if (match) {
+				let range = new Range(new Position(pos.line, match[1].length), pos);
+				let beginProposal = new CompletionItem('#region', CompletionItemKind.Snippet);
+				beginProposal.range = range;
+				beginProposal.insertText = new SnippetString('<!-- #region $1-->');
+				beginProposal.documentation = localize('folding.start', 'Folding Region Start');
+				beginProposal.filterText = match[2];
+				beginProposal.sortText = 'za';
+				results.push(beginProposal);
+				let endProposal = new CompletionItem('#endregion', CompletionItemKind.Snippet);
+				endProposal.range = range;
+				endProposal.insertText = new SnippetString('<!-- #endregion -->');
+				endProposal.documentation = localize('folding.end', 'Folding Region End');
+				endProposal.filterText = match[2];
+				endProposal.sortText = 'zb';
+				results.push(endProposal);
+			}
+			let match2 = lineUntilPos.match(htmlSnippetCompletionRegExpr);
+			if (match2 && doc.getText(new Range(new Position(0, 0), pos)).match(htmlSnippetCompletionRegExpr)) {
+				let range = new Range(new Position(pos.line, match2[1].length), pos);
+				let snippetProposal = new CompletionItem('HTML sample', CompletionItemKind.Snippet);
+				snippetProposal.range = range;
+				const content = ['<!DOCTYPE html>',
+					'<html>',
+					'<head>',
+					'\t<meta charset=\'utf-8\'>',
+					'\t<meta http-equiv=\'X-UA-Compatible\' content=\'IE=edge\'>',
+					'\t<title>${1:Page Title}</title>',
+					'\t<meta name=\'viewport\' content=\'width=device-width, initial-scale=1\'>',
+					'\t<link rel=\'stylesheet\' type=\'text/css\' media=\'screen\' href=\'${2:main.css}\'>',
+					'\t<script src=\'${3:main.js}\'></script>',
+					'</head>',
+					'<body>',
+					'\t$0',
+					'</body>',
+					'</html>'].join('\n');
+				snippetProposal.insertText = new SnippetString(content);
+				snippetProposal.documentation = localize('folding.html', 'Simple HTML5 starting point');
+				snippetProposal.filterText = match2[2];
+				snippetProposal.sortText = 'za';
+				results.push(snippetProposal);
+			}
+			return results;
+		}
+	});
+
+	const promptForTypeOnRenameKey = 'html.promptForTypeOnRename';
+	const promptForTypeOnRename = extensions.getExtension('formulahendry.auto-rename-tag') !== undefined &&
+		(context.globalState.get(promptForTypeOnRenameKey) !== false) &&
+		!workspace.getConfiguration('editor', { languageId: 'html' }).get('renameOnType');
+
+	if (promptForTypeOnRename) {
+		const activeEditorListener = window.onDidChangeActiveTextEditor(async e => {
+			if (e && documentSelector.indexOf(e.document.languageId) !== -1) {
+				context.globalState.update(promptForTypeOnRenameKey, false);
+				activeEditorListener.dispose();
+				const configure = localize('configureButton', 'Configure');
+				const res = await window.showInformationMessage(localize('renameOnTypeQuestion', 'VS Code now has built-in support for auto-renaming tags. Do you want to enable it?'), configure);
+				if (res === configure) {
+					commands.executeCommand('workbench.action.openSettings', SettingIds.renameOnType);
+				}
+			}
+		});
+		toDispose.push(activeEditorListener);
+	}
+
+	toDispose.push();
+}

lib/vscode/extensions/html-language-features/client/src/htmlEmptyTagsShared.ts

@@ -0,0 +1,6 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export const EMPTY_ELEMENTS: string[] = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr'];

lib/vscode/extensions/html-language-features/client/src/node/htmlClientMain.ts

@@ -0,0 +1,58 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { getNodeFSRequestService } from './nodeFs';
+import { ExtensionContext } from 'vscode';
+import { startClient, LanguageClientConstructor } from '../htmlClient';
+import { ServerOptions, TransportKind, LanguageClientOptions, LanguageClient } from 'vscode-languageclient/node';
+import { TextDecoder } from 'util';
+import * as fs from 'fs';
+import TelemetryReporter from 'vscode-extension-telemetry';
+
+
+let telemetry: TelemetryReporter | undefined;
+
+// this method is called when vs code is activated
+export function activate(context: ExtensionContext) {
+
+	let clientPackageJSON = getPackageInfo(context);
+	telemetry = new TelemetryReporter(clientPackageJSON.name, clientPackageJSON.version, clientPackageJSON.aiKey);
+
+	const serverMain = `./server/${clientPackageJSON.main.indexOf('/dist/') !== -1 ? 'dist' : 'out'}/node/htmlServerMain`;
+	const serverModule = context.asAbsolutePath(serverMain);
+
+	// The debug options for the server
+	const debugOptions = { execArgv: ['--nolazy', '--inspect=6044'] };
+
+	// If the extension is launch in debug mode the debug server options are use
+	// Otherwise the run options are used
+	const serverOptions: ServerOptions = {
+		run: { module: serverModule, transport: TransportKind.ipc },
+		debug: { module: serverModule, transport: TransportKind.ipc, options: debugOptions }
+	};
+
+	const newLanguageClient: LanguageClientConstructor = (id: string, name: string, clientOptions: LanguageClientOptions) => {
+		return new LanguageClient(id, name, serverOptions, clientOptions);
+	};
+
+	startClient(context, newLanguageClient, { fs: getNodeFSRequestService(), TextDecoder, telemetry });
+}
+
+interface IPackageInfo {
+	name: string;
+	version: string;
+	aiKey: string;
+	main: string;
+}
+
+function getPackageInfo(context: ExtensionContext): IPackageInfo {
+	const location = context.asAbsolutePath('./package.json');
+	try {
+		return JSON.parse(fs.readFileSync(location).toString());
+	} catch (e) {
+		console.log(`Problems reading ${location}: ${e}`);
+		return { name: '', version: '', aiKey: '', main: '' };
+	}
+}

lib/vscode/extensions/html-language-features/client/src/node/nodeFs.ts

@@ -0,0 +1,85 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as fs from 'fs';
+import { Uri } from 'vscode';
+import { getScheme, RequestService, FileType } from '../requests';
+
+export function getNodeFSRequestService(): RequestService {
+	function ensureFileUri(location: string) {
+		if (getScheme(location) !== 'file') {
+			throw new Error('fileRequestService can only handle file URLs');
+		}
+	}
+	return {
+		getContent(location: string, encoding?: string) {
+			ensureFileUri(location);
+			return new Promise((c, e) => {
+				const uri = Uri.parse(location);
+				fs.readFile(uri.fsPath, encoding, (err, buf) => {
+					if (err) {
+						return e(err);
+					}
+					c(buf.toString());
+
+				});
+			});
+		},
+		stat(location: string) {
+			ensureFileUri(location);
+			return new Promise((c, e) => {
+				const uri = Uri.parse(location);
+				fs.stat(uri.fsPath, (err, stats) => {
+					if (err) {
+						if (err.code === 'ENOENT') {
+							return c({ type: FileType.Unknown, ctime: -1, mtime: -1, size: -1 });
+						} else {
+							return e(err);
+						}
+					}
+
+					let type = FileType.Unknown;
+					if (stats.isFile()) {
+						type = FileType.File;
+					} else if (stats.isDirectory()) {
+						type = FileType.Directory;
+					} else if (stats.isSymbolicLink()) {
+						type = FileType.SymbolicLink;
+					}
+
+					c({
+						type,
+						ctime: stats.ctime.getTime(),
+						mtime: stats.mtime.getTime(),
+						size: stats.size
+					});
+				});
+			});
+		},
+		readDirectory(location: string) {
+			ensureFileUri(location);
+			return new Promise((c, e) => {
+				const path = Uri.parse(location).fsPath;
+
+				fs.readdir(path, { withFileTypes: true }, (err, children) => {
+					if (err) {
+						return e(err);
+					}
+					c(children.map(stat => {
+						if (stat.isSymbolicLink()) {
+							return [stat.name, FileType.SymbolicLink];
+						} else if (stat.isDirectory()) {
+							return [stat.name, FileType.Directory];
+						} else if (stat.isFile()) {
+							return [stat.name, FileType.File];
+						} else {
+							return [stat.name, FileType.Unknown];
+						}
+					}));
+				});
+			});
+		}
+	};
+}

lib/vscode/extensions/html-language-features/client/src/requests.ts

@@ -0,0 +1,148 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Uri, workspace } from 'vscode';
+import { RequestType, CommonLanguageClient } from 'vscode-languageclient';
+import { Runtime } from './htmlClient';
+
+export namespace FsContentRequest {
+	export const type: RequestType<{ uri: string; encoding?: string; }, string, any, any> = new RequestType('fs/content');
+}
+export namespace FsStatRequest {
+	export const type: RequestType<string, FileStat, any, any> = new RequestType('fs/stat');
+}
+
+export namespace FsReadDirRequest {
+	export const type: RequestType<string, [string, FileType][], any, any> = new RequestType('fs/readDir');
+}
+
+export function serveFileSystemRequests(client: CommonLanguageClient, runtime: Runtime) {
+	client.onRequest(FsContentRequest.type, (param: { uri: string; encoding?: string; }) => {
+		const uri = Uri.parse(param.uri);
+		if (uri.scheme === 'file' && runtime.fs) {
+			return runtime.fs.getContent(param.uri);
+		}
+		return workspace.fs.readFile(uri).then(buffer => {
+			return new runtime.TextDecoder(param.encoding).decode(buffer);
+		});
+	});
+	client.onRequest(FsReadDirRequest.type, (uriString: string) => {
+		const uri = Uri.parse(uriString);
+		if (uri.scheme === 'file' && runtime.fs) {
+			return runtime.fs.readDirectory(uriString);
+		}
+		return workspace.fs.readDirectory(uri);
+	});
+	client.onRequest(FsStatRequest.type, (uriString: string) => {
+		const uri = Uri.parse(uriString);
+		if (uri.scheme === 'file' && runtime.fs) {
+			return runtime.fs.stat(uriString);
+		}
+		return workspace.fs.stat(uri);
+	});
+}
+
+export enum FileType {
+	/**
+	 * The file type is unknown.
+	 */
+	Unknown = 0,
+	/**
+	 * A regular file.
+	 */
+	File = 1,
+	/**
+	 * A directory.
+	 */
+	Directory = 2,
+	/**
+	 * A symbolic link to a file.
+	 */
+	SymbolicLink = 64
+}
+export interface FileStat {
+	/**
+	 * The type of the file, e.g. is a regular file, a directory, or symbolic link
+	 * to a file.
+	 */
+	type: FileType;
+	/**
+	 * The creation timestamp in milliseconds elapsed since January 1, 1970 00:00:00 UTC.
+	 */
+	ctime: number;
+	/**
+	 * The modification timestamp in milliseconds elapsed since January 1, 1970 00:00:00 UTC.
+	 */
+	mtime: number;
+	/**
+	 * The size in bytes.
+	 */
+	size: number;
+}
+
+export interface RequestService {
+	getContent(uri: string, encoding?: string): Promise<string>;
+
+	stat(uri: string): Promise<FileStat>;
+	readDirectory(uri: string): Promise<[string, FileType][]>;
+}
+
+export function getScheme(uri: string) {
+	return uri.substr(0, uri.indexOf(':'));
+}
+
+export function dirname(uri: string) {
+	const lastIndexOfSlash = uri.lastIndexOf('/');
+	return lastIndexOfSlash !== -1 ? uri.substr(0, lastIndexOfSlash) : '';
+}
+
+export function basename(uri: string) {
+	const lastIndexOfSlash = uri.lastIndexOf('/');
+	return uri.substr(lastIndexOfSlash + 1);
+}
+
+const Slash = '/'.charCodeAt(0);
+const Dot = '.'.charCodeAt(0);
+
+export function isAbsolutePath(path: string) {
+	return path.charCodeAt(0) === Slash;
+}
+
+export function resolvePath(uri: Uri, path: string): Uri {
+	if (isAbsolutePath(path)) {
+		return uri.with({ path: normalizePath(path.split('/')) });
+	}
+	return joinPath(uri, path);
+}
+
+export function normalizePath(parts: string[]): string {
+	const newParts: string[] = [];
+	for (const part of parts) {
+		if (part.length === 0 || part.length === 1 && part.charCodeAt(0) === Dot) {
+			// ignore
+		} else if (part.length === 2 && part.charCodeAt(0) === Dot && part.charCodeAt(1) === Dot) {
+			newParts.pop();
+		} else {
+			newParts.push(part);
+		}
+	}
+	if (parts.length > 1 && parts[parts.length - 1].length === 0) {
+		newParts.push('');
+	}
+	let res = newParts.join('/');
+	if (parts[0].length === 0) {
+		res = '/' + res;
+	}
+	return res;
+}
+
+
+export function joinPath(uri: Uri, ...paths: string[]): Uri {
+	const parts = uri.path.split('/');
+	for (let path of paths) {
+		parts.push(...path.split('/'));
+	}
+	return uri.with({ path: normalizePath(parts) });
+}

lib/vscode/extensions/html-language-features/client/src/tagClosing.ts

@@ -0,0 +1,75 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { window, workspace, Disposable, TextDocumentContentChangeEvent, TextDocument, Position, SnippetString } from 'vscode';
+
+export function activateTagClosing(tagProvider: (document: TextDocument, position: Position) => Thenable<string>, supportedLanguages: { [id: string]: boolean }, configName: string): Disposable {
+
+	let disposables: Disposable[] = [];
+	workspace.onDidChangeTextDocument(event => onDidChangeTextDocument(event.document, event.contentChanges), null, disposables);
+
+	let isEnabled = false;
+	updateEnabledState();
+	window.onDidChangeActiveTextEditor(updateEnabledState, null, disposables);
+
+	let timeout: NodeJS.Timer | undefined = undefined;
+
+	function updateEnabledState() {
+		isEnabled = false;
+		let editor = window.activeTextEditor;
+		if (!editor) {
+			return;
+		}
+		let document = editor.document;
+		if (!supportedLanguages[document.languageId]) {
+			return;
+		}
+		if (!workspace.getConfiguration(undefined, document.uri).get<boolean>(configName)) {
+			return;
+		}
+		isEnabled = true;
+	}
+
+	function onDidChangeTextDocument(document: TextDocument, changes: readonly TextDocumentContentChangeEvent[]) {
+		if (!isEnabled) {
+			return;
+		}
+		let activeDocument = window.activeTextEditor && window.activeTextEditor.document;
+		if (document !== activeDocument || changes.length === 0) {
+			return;
+		}
+		if (typeof timeout !== 'undefined') {
+			clearTimeout(timeout);
+		}
+		let lastChange = changes[changes.length - 1];
+		let lastCharacter = lastChange.text[lastChange.text.length - 1];
+		if (lastChange.rangeLength > 0 || lastCharacter !== '>' && lastCharacter !== '/') {
+			return;
+		}
+		let rangeStart = lastChange.range.start;
+		let version = document.version;
+		timeout = setTimeout(() => {
+			let position = new Position(rangeStart.line, rangeStart.character + lastChange.text.length);
+			tagProvider(document, position).then(text => {
+				if (text && isEnabled) {
+					let activeEditor = window.activeTextEditor;
+					if (activeEditor) {
+						let activeDocument = activeEditor.document;
+						if (document === activeDocument && activeDocument.version === version) {
+							let selections = activeEditor.selections;
+							if (selections.length && selections.some(s => s.active.isEqual(position))) {
+								activeEditor.insertSnippet(new SnippetString(text), selections.map(s => s.active));
+							} else {
+								activeEditor.insertSnippet(new SnippetString(text), position);
+							}
+						}
+					}
+				}
+			});
+			timeout = undefined;
+		}, 100);
+	}
+	return Disposable.from(...disposables);
+}

lib/vscode/extensions/html-language-features/client/src/typings/ref.d.ts

@@ -0,0 +1,7 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/// <reference path='../../../../../src/vs/vscode.d.ts'/>
+/// <reference path="../../../../../src/vs/vscode.proposed.d.ts" />